tessera-learn 0.2.3 → 0.4.0

package/src/runtime/adapters/xapi-launch-base.ts

@@ -0,0 +1,346 @@
+import type { PersistenceAdapter, SavedState } from '../persistence.js';
+import type { Interaction } from '../interaction.js';
+import {
+  formatResponse,
+  formatCorrectPattern,
+  XAPI_INTERACTION_FORMAT,
+} from '../interaction-format.js';
+import { formatISO8601Duration } from './format.js';
+import { XAPIPublisher } from '../xapi/publisher.js';
+import type { XAPIAgent, PartialStatement } from '../xapi/types.js';
+
+export const VERBS = {
+  initialized: 'http://adlnet.gov/expapi/verbs/initialized',
+  answered: 'http://adlnet.gov/expapi/verbs/answered',
+  completed: 'http://adlnet.gov/expapi/verbs/completed',
+  passed: 'http://adlnet.gov/expapi/verbs/passed',
+  failed: 'http://adlnet.gov/expapi/verbs/failed',
+  terminated: 'http://adlnet.gov/expapi/verbs/terminated',
+} as const;
+
+const CMI_INTERACTION_TYPE =
+  'http://adlnet.gov/expapi/activities/cmi.interaction';
+
+/**
+ * Version-neutral xAPI launch lifecycle shared by the cmi5 and plain-xAPI
+ * adapters. Subclasses set the protected fields in init() and may override
+ * buildContext()/isDefinedStatementAllowed()/scoreForSuccess() to layer
+ * profile rules on top.
+ */
+export abstract class BaseXAPILaunchAdapter implements PersistenceAdapter {
+  protected publisher: XAPIPublisher | null = null;
+  protected endpoint = '';
+  protected activityId = '';
+  protected actor: XAPIAgent | null = null;
+  protected registration: string | undefined;
+  protected authToken = '';
+  protected version = '1.0.3';
+  /** Prefix for this adapter's console warnings (e.g. "cmi5", "xAPI"). */
+  protected logName = 'xAPI';
+
+  protected score: number | null = null;
+  protected durationSeconds = 0;
+  protected state: SavedState | null = null;
+  protected completedEmitted = false;
+  protected lastSuccessEmitted: 'unknown' | 'passed' | 'failed' = 'unknown';
+  protected terminated = false;
+  protected returnURL: string | undefined;
+
+  abstract init(): Promise<void>;
+
+  /** Profile context for a Defined Statement. Plain xAPI adds nothing — the publisher injects context.registration on its own. */
+  protected buildContext(
+    _opts: { moveOn?: boolean; mastery?: boolean } = {},
+  ): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
+  /** cmi5 Browse/Review gating hook. Plain xAPI always allows. */
+  protected isDefinedStatementAllowed(): boolean {
+    return true;
+  }
+
+  /** Scaled score to attach to Passed/Failed, or null to omit. cmi5 overrides for masteryScore gating. */
+  protected scoreForSuccess(_status: 'passed' | 'failed'): number | null {
+    return this.score !== null ? this.score / 100 : null;
+  }
+
+  getPublisher(): XAPIPublisher | null {
+    return this.publisher;
+  }
+
+  getState(): SavedState | null {
+    return this.state;
+  }
+
+  saveState(state: SavedState): void {
+    this.state = state;
+    if (!this.publisher) return;
+    void this.publisher.chainTask(async () => {
+      try {
+        const resp = await this.xapiFetch(this.buildStateUrl(), {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(state),
+        });
+        if (!resp.ok) {
+          console.warn(
+            `Tessera ${this.logName}: State API PUT returned ${resp.status}; learner progress did not persist.`,
+          );
+        }
+      } catch (err) {
+        console.warn(`Tessera ${this.logName}: Failed to save state`, err);
+      }
+    });
+  }
+
+  setScore(score: number): void {
+    if (!Number.isFinite(score)) {
+      this.score = null;
+      return;
+    }
+    this.score = Math.max(0, Math.min(100, score));
+  }
+
+  setDuration(seconds: number): void {
+    this.durationSeconds = seconds;
+  }
+
+  setExit(_mode: 'suspend' | 'normal'): void {
+    // No cmi.exit analogue in xAPI; suspend is implicit. No-op.
+  }
+
+  commit(): void {
+    // Statements are sent individually. No-op.
+  }
+
+  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.completedEmitted || !this.publisher)
+      return;
+    if (!this.isDefinedStatementAllowed()) return;
+    this.completedEmitted = true;
+    const result: Record<string, unknown> = {
+      completion: true,
+      duration: formatISO8601Duration(this.durationSeconds),
+    };
+    this.dispatch('Completed', {
+      verb: { id: VERBS.completed, display: { 'en-US': 'completed' } },
+      result,
+      context: this.buildContext({ moveOn: true }),
+    });
+  }
+
+  setSuccessStatus(status: 'passed' | 'failed' | 'unknown'): void {
+    if (status === 'unknown' || !this.publisher) return;
+    if (status === this.lastSuccessEmitted) return;
+    if (!this.isDefinedStatementAllowed()) return;
+    this.lastSuccessEmitted = status;
+
+    const verb = status === 'passed' ? VERBS.passed : VERBS.failed;
+    const verbName = status === 'passed' ? 'passed' : 'failed';
+    const result: Record<string, unknown> = {
+      success: status === 'passed',
+      duration: formatISO8601Duration(this.durationSeconds),
+    };
+    const scaled = this.scoreForSuccess(status);
+    if (scaled !== null) result.score = { scaled };
+    this.dispatch(status === 'passed' ? 'Passed' : 'Failed', {
+      verb: { id: verb, display: { 'en-US': verbName } },
+      result,
+      context: this.buildContext({ moveOn: true, mastery: true }),
+    });
+  }
+
+  reportInteraction(
+    questionId: string,
+    interaction: Interaction,
+    correct: boolean | null,
+  ): void {
+    if (!this.publisher) return;
+    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,
+    };
+    if (pattern !== null) {
+      definition.correctResponsesPattern = [pattern];
+    }
+    const result: Record<string, unknown> = { response };
+    if (correct !== null) {
+      result.success = correct;
+    }
+    this.dispatch('Answered', {
+      verb: { id: VERBS.answered, display: { 'en-US': 'answered' } },
+      object: {
+        id: `${this.activityId}#${questionId}`,
+        objectType: 'Activity',
+        definition,
+      },
+      result,
+    });
+  }
+
+  terminate(): void {
+    if (this.terminated) return;
+    this.terminated = true;
+    if (!this.publisher) return;
+    this.publisher.markUnloading();
+    const duration = formatISO8601Duration(this.durationSeconds);
+    this.dispatch('Terminated', {
+      verb: { id: VERBS.terminated, display: { 'en-US': 'terminated' } },
+      result: { duration },
+      context: this.buildContext(),
+    });
+  }
+
+  async exit(): Promise<void> {
+    this.terminate();
+    if (this.publisher) {
+      try {
+        await this.publisher.chainTask(async () => {});
+      } catch {
+        // never rejects today; don't block redirect.
+      }
+    }
+    if (this.returnURL && typeof window !== 'undefined') {
+      window.location.assign(this.returnURL);
+    }
+  }
+
+  /** Parse the launch `actor` param into an Identified Agent, failing loud on malformed JSON. */
+  protected parseActorParam(raw: string): void {
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== 'object') {
+        throw new Error('actor must be an object');
+      }
+      this.actor = parsed as XAPIAgent;
+    } catch (err) {
+      throw new Error(
+        `Tessera ${this.logName}: launch parameter 'actor' is malformed (${err instanceof Error ? err.message : String(err)}). The LMS did not send a valid Identified Agent JSON.`,
+        { cause: err },
+      );
+    }
+  }
+
+  /** Construct the publisher from the resolved launch fields plus per-profile options. */
+  protected createPublisher(opts: {
+    sessionId?: string;
+    cmi5Mode?: boolean;
+  }): XAPIPublisher {
+    if (!this.actor) {
+      throw new Error(
+        `Tessera ${this.logName}: cannot create publisher before the launch actor is resolved.`,
+      );
+    }
+    this.publisher = new XAPIPublisher({
+      endpoint: this.endpoint,
+      auth: this.authToken,
+      actor: this.actor,
+      activityId: this.activityId,
+      registration: this.registration,
+      version: this.version,
+      ...opts,
+    });
+    return this.publisher;
+  }
+
+  /** Fire-and-forget Initialized statement (the first Defined Statement of the session). */
+  protected sendInitialized(): void {
+    this.dispatch('Initialized', {
+      verb: { id: VERBS.initialized, display: { 'en-US': 'initialized' } },
+      context: this.buildContext(),
+    });
+  }
+
+  /** Enqueue a lifecycle statement fire-and-forget. `label` names it in both the LRS-reject and send-failure warnings. */
+  protected dispatch(label: string, partial: PartialStatement): void {
+    if (!this.publisher) return;
+    this.publisher
+      .sendStatement(partial)
+      .then(this.warnOnLRSReject(label))
+      .catch((err) => {
+        console.warn(
+          `Tessera ${this.logName}: failed to send ${label} statement`,
+          err,
+        );
+      });
+  }
+
+  /** `.then` handler that warns on LRS non-2xx. The publisher resolves successfully on 4xx/5xx (failure is in the destination outcome), so `.catch` alone misses them. */
+  protected warnOnLRSReject(
+    label: string,
+  ): (res: {
+    destinations?: Array<{ ok?: boolean; status?: number; error?: Error }>;
+  }) => void {
+    const logName = this.logName;
+    return (res) => {
+      const dest = res.destinations?.[0];
+      if (dest && !dest.ok) {
+        console.warn(
+          `Tessera ${logName}: ${label} statement rejected by LRS (${dest.status ?? 'network error'})`,
+          dest.error,
+        );
+      }
+    };
+  }
+
+  protected buildStateUrl(stateId: string = 'tessera-state'): string {
+    const params = new URLSearchParams({
+      activityId: this.activityId,
+      agent: JSON.stringify(this.actor),
+      stateId,
+    });
+    if (this.registration) params.set('registration', this.registration);
+    return `${this.endpoint}activities/state?${params.toString()}`;
+  }
+
+  protected async xapiFetch(
+    url: string,
+    options: RequestInit = {},
+  ): Promise<Response> {
+    const headers = new Headers(options.headers);
+    if (this.authToken) {
+      headers.set('Authorization', `Basic ${this.authToken}`);
+    }
+    headers.set('X-Experience-API-Version', this.version);
+    const keepalive = this.publisher?.isUnloading() ?? false;
+    return fetch(url, {
+      ...options,
+      headers,
+      ...(keepalive ? { keepalive: true } : {}),
+    });
+  }
+
+  /** Shared resume GET — call from a subclass init() after the publisher exists. */
+  protected async loadResumeState(): Promise<void> {
+    try {
+      const resp = await this.xapiFetch(this.buildStateUrl(), {
+        method: 'GET',
+      });
+      if (resp.ok) {
+        this.state = await resp.json();
+      } else if (resp.status !== 404) {
+        console.warn(
+          `Tessera ${this.logName}: State API GET returned ${resp.status}; resume disabled for this launch.`,
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `Tessera ${this.logName}: State API GET failed (${err instanceof Error ? err.message : String(err)}); resume disabled for this launch.`,
+      );
+      this.state = null;
+    }
+  }
+}

package/src/runtime/adapters/xapi.ts

@@ -0,0 +1,26 @@
+import { BaseXAPILaunchAdapter } from './xapi-launch-base.js';
+
+/**
+ * Plain xAPI ("Tin Can") launch adapter. Reads launch params straight off the
+ * URL — no cmi5 fetch-token, no LMS.LaunchData, no cmi5 context.
+ */
+export class XAPIAdapter extends BaseXAPILaunchAdapter {
+  async init(): Promise<void> {
+    const params = new URLSearchParams(window.location.search);
+    this.endpoint = (params.get('endpoint') || '').replace(/\/?$/, '/');
+    // Tin Can uses snake_case `activity_id` (NOT cmi5's camelCase `activityId`).
+    this.activityId = params.get('activity_id') || '';
+    const reg = params.get('registration') || '';
+    this.registration = reg ? reg : undefined;
+    // Tin Can launch passes `auth` as the full "Basic <base64>" header value;
+    // strip the scheme so we don't double-prefix it when sending.
+    this.authToken = (params.get('auth') || '').replace(/^Basic\s+/i, '');
+    this.parseActorParam(params.get('actor') || '');
+
+    const publisher = this.createPublisher({});
+    await publisher.init();
+
+    this.sendInitialized();
+    await this.loadResumeState();
+  }
+}

package/src/runtime/fingerprint.ts

@@ -0,0 +1,28 @@
+import type { Manifest } from '../plugin/manifest.js';
+import type { SavedState } from './persistence.js';
+
+// FNV-1a over the ordered page slugs. SavedState is keyed by page index, so a
+// structure change must change the fingerprint — else stale state restores onto
+// the wrong pages. Slugs can't contain a NUL, so it's a collision-proof delimiter.
+export function structureFingerprint(manifest: Manifest): string {
+  const slugs = manifest.pages.map((p) => p.slug).join('\0');
+  let h = 0x811c9dc5;
+  for (let i = 0; i < slugs.length; i++) {
+    h ^= slugs.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(36);
+}
+
+// `never` always starts fresh; otherwise a saved fingerprint that no longer
+// matches the current structure is discarded. State saved before fingerprinting
+// (no `f`) is trusted so upgrading the runtime never wipes an in-progress learner.
+export function shouldRestore(
+  saved: SavedState,
+  currentFingerprint: string,
+  resume: 'auto' | 'never' = 'auto',
+): boolean {
+  if (resume === 'never') return false;
+  if (saved.f !== undefined && saved.f !== currentFingerprint) return false;
+  return true;
+}

package/src/runtime/interaction-format.ts

@@ -165,7 +165,6 @@ export function formatCorrectPattern(
 export function scorm12Type(type: Interaction['type']): string {
   switch (type) {
     case 'long-fill-in':
-      return 'fill-in';
     case 'other':
       return 'fill-in';
     default:

package/src/runtime/persistence.ts

@@ -60,4 +60,8 @@ export interface SavedState {
   gs?: number[];
   /** Manual completion latch. 1 if the learner triggered manual completion. Absent otherwise. */
   m?: 1;
+  /** Structure fingerprint (FNV-1a over ordered page slugs) at save time.
+   * On resume, a mismatch discards the blob — the course structure changed.
+   * Absent on state saved before fingerprinting; treated as a match. */
+  f?: string;
 }

package/src/runtime/types.ts

@@ -9,6 +9,15 @@ import type { XAPIAgent } from './xapi/types.js';
 export const FEEDBACK_MODES = ['review', 'immediate', 'never'] as const;
 export const RETRY_MODES = ['full', 'incorrect-only'] as const;
 
+/**
+ * Trimmed course identity, or '' when absent. Single source of truth for the
+ * "is there a usable id?" check shared by the web storage key, the cmi5/xAPI
+ * id derivation, and the config validator.
+ */
+export function courseIdentity(config: { id?: unknown }): string {
+  return (typeof config.id === 'string' && config.id.trim()) || '';
+}
+
 /**
  * Per-page quiz configuration. Single source of truth — the build plugin
  * extracts this from `pageConfig.quiz` and embeds it in the manifest;
@@ -24,9 +33,16 @@ export interface QuizConfig {
 
 export interface CourseConfig {
   title: string;
+  /** Stable, unique course identity (e.g. 'urn:uuid:…'). Seeds the web
+   * localStorage key and the cmi5/xAPI LRS activity id; scaffolders generate one.
+   * Absent → both fall back to a fixed value, colliding across courses. */
+  id?: string;
   description?: string;
   author?: string;
   version?: string;
+  /** Resume policy. 'auto' (default) restores saved progress unless the page
+   * structure changed since it was saved; 'never' always starts fresh. */
+  resume?: 'auto' | 'never';
   /** BCP-47 language tag for <html lang>. Defaults to 'en'. WCAG 3.1.1. */
   language?: string;
   /** Accessibility checker configuration. */
@@ -46,7 +62,12 @@ export interface CourseConfig {
     passingScore: number;
   };
   export: {
-    standard: 'web' | 'scorm12' | 'scorm2004' | 'cmi5';
+    standard: 'web' | 'scorm12' | 'scorm2004' | 'cmi5' | 'xapi';
+    /** Web export only: extend the baseline Content-Security-Policy. Each key is
+     * a directive; its sources are appended (unioned) onto the baseline. `false`
+     * drops the CSP meta entirely (for deployments that set a CSP header).
+     * Ignored unless `standard` is 'web'. */
+    csp?: false | Record<string, string[]>;
   };
   /**
    * Optional xAPI destination(s) for custom statement publishing via

package/src/runtime/xapi/publisher.ts

@@ -46,6 +46,8 @@ export interface XAPIPublisherOptions {
    * Set by the cmi5 adapter and by 'lms'-inherited destinations under cmi5.
    */
   cmi5Mode?: boolean;
+  /** xAPI version for the X-Experience-API-Version header. Defaults to X_API_VERSION (1.0.3). */
+  version?: string;
   /** When set, every send method rejects with the returned Error without hitting the network. */
   unavailableReason?: () => Error;
 }
@@ -94,6 +96,7 @@ export class XAPIPublisher {
   readonly #registration?: string;
   readonly #sessionId: string;
   readonly #cmi5Mode: boolean;
+  readonly #version: string;
 
   // When set, every send method short-circuits with a rejected promise.
   readonly #unavailableReason: (() => Error) | null;
@@ -138,6 +141,7 @@ export class XAPIPublisher {
     this.#activityId = opts.activityId;
     this.#registration = opts.registration;
     this.#cmi5Mode = !!opts.cmi5Mode;
+    this.#version = opts.version ?? X_API_VERSION;
     this.#authValue = opts.auth;
     this.#actorValue = opts.actor;
     this.#sessionId = opts.sessionId ?? uuidv4();
@@ -485,22 +489,26 @@ export class XAPIPublisher {
   #buildHeaders(token: string): Headers {
     const headers = new Headers();
     if (token) headers.set('Authorization', `Basic ${token}`);
-    headers.set('X-Experience-API-Version', X_API_VERSION);
+    headers.set('X-Experience-API-Version', this.#version);
     headers.set('Content-Type', 'application/json');
     return headers;
   }
 
-  #fetchWithToken(
-    token: string,
-    body: string,
-    keepalive: boolean,
-  ): Promise<SendOutcome> {
+  #post(token: string, body: string, keepalive: boolean): Promise<Response> {
     return fetch(this.#statementsUrl, {
       method: 'POST',
       headers: this.#buildHeaders(token),
       body,
       keepalive,
-    })
+    });
+  }
+
+  #fetchWithToken(
+    token: string,
+    body: string,
+    keepalive: boolean,
+  ): Promise<SendOutcome> {
+    return this.#post(token, body, keepalive)
       .then((resp) => this.#handleResponse(resp, body, keepalive))
       .catch((err) => ({
         ok: false,
@@ -525,14 +533,7 @@ export class XAPIPublisher {
     ) {
       this.#cachedAuth = null;
       return this.#resolveAuth(true)
-        .then((newToken) =>
-          fetch(this.#statementsUrl, {
-            method: 'POST',
-            headers: this.#buildHeaders(newToken),
-            body,
-            keepalive,
-          }),
-        )
+        .then((newToken) => this.#post(newToken, body, keepalive))
         .then((retryResp): SendOutcome => {
           if (retryResp.ok || retryResp.status === 409) {
             return { ok: true, status: retryResp.status };

package/src/runtime/xapi/setup.ts

@@ -7,18 +7,19 @@ import {
   synthesizeSCORM12Actor,
   synthesizeSCORM2004Actor,
 } from './derive-actor.js';
-import { CMI5Adapter } from '../adapters/cmi5.js';
+import { BaseXAPILaunchAdapter } from '../adapters/xapi-launch-base.js';
 import { SCORM12Adapter } from '../adapters/scorm12.js';
 import { SCORM2004Adapter } from '../adapters/scorm2004.js';
 
 /**
  * Wraps a value that the runtime knows how to materialize into an
  * `XAPIPublisher`. Either a fresh publisher constructed for an explicit
- * destination, or a reference to the cmi5 adapter's existing publisher
- * (for the `endpoint: 'lms'` sentinel — same instance, shared queue).
+ * destination, or a reference to a launch adapter's existing publisher
+ * (for the `endpoint: 'lms'` sentinel — same instance, shared queue). Both
+ * the cmi5 and plain-xAPI adapters expose that publisher via the base.
  */
 type DestinationSource =
-  | { kind: 'lms-shared'; adapter: CMI5Adapter }
+  | { kind: 'lms-shared'; adapter: BaseXAPILaunchAdapter }
   | { kind: 'explicit'; publisher: XAPIPublisher };
 
 /**
@@ -29,10 +30,13 @@ type DestinationSource =
  * produces the "works in dev, silently broken in prod" footgun.
  */
 class XAPIDevFallbackError extends Error {
-  constructor() {
+  constructor(standard: 'cmi5' | 'xapi') {
+    const missing =
+      standard === 'cmi5'
+        ? 'cmi5 launch parameters (fetch / endpoint / activityId / actor)'
+        : 'xAPI launch parameters (endpoint / auth / actor / activity_id)';
     super(
-      "Tessera xAPI: xapi.endpoint is 'lms' but no cmi5 launch parameters " +
-        '(fetch / endpoint / activityId / actor) were present on the URL. ' +
+      `Tessera xAPI: xapi.endpoint is 'lms' but no ${missing} were present on the URL. ` +
         'Either launch this course from a real LMS / SCORM Cloud, or ' +
         'temporarily change xapi.endpoint to an explicit URL pointed at a ' +
         'local LRS (e.g. http://localhost:8080/data/xAPI/) for dev work.',
@@ -59,8 +63,8 @@ function makeRejectingPublisher(error: () => Error): XAPIPublisher {
   });
 }
 
-function makeDevFallbackPublisher(): XAPIPublisher {
-  return makeRejectingPublisher(() => new XAPIDevFallbackError());
+function makeDevFallbackPublisher(standard: 'cmi5' | 'xapi'): XAPIPublisher {
+  return makeRejectingPublisher(() => new XAPIDevFallbackError(standard));
 }
 
 class XAPISCORMDevFallbackError extends Error {
@@ -100,20 +104,21 @@ function resolveDestination(
   adapter: PersistenceAdapter | null,
 ): DestinationSource | null {
   if (entry.endpoint === 'lms') {
-    if (config.export?.standard !== 'cmi5') {
+    const standard = config.export?.standard;
+    if (standard !== 'cmi5' && standard !== 'xapi') {
       // Build-time validator should reject this; defense in depth at runtime.
       console.warn(
-        "Tessera xAPI: ignoring xapi entry with endpoint: 'lms' under non-cmi5 export.",
+        "Tessera xAPI: ignoring xapi entry with endpoint: 'lms' under a non-launch export.",
       );
       return null;
     }
-    if (adapter instanceof CMI5Adapter) {
+    if (adapter instanceof BaseXAPILaunchAdapter) {
       return { kind: 'lms-shared', adapter };
     }
-    // Dev fallback — cmi5 launch params absent, adapter is the WebAdapter
+    // Dev fallback — launch params absent, adapter is the WebAdapter
     // fallback. Materialize a publisher whose sends reject with an
     // explicit error so author code surfaces the dev/prod gap.
-    return { kind: 'explicit', publisher: makeDevFallbackPublisher() };
+    return { kind: 'explicit', publisher: makeDevFallbackPublisher(standard) };
   }
 
   // Explicit endpoint.
@@ -151,7 +156,11 @@ function resolveExplicitActor(
   if (explicit.actor !== undefined) {
     return { kind: 'actor', value: explicit.actor };
   }
-  if (config.export?.standard === 'cmi5' && adapter instanceof CMI5Adapter) {
+  const standard = config.export?.standard;
+  if (
+    (standard === 'cmi5' || standard === 'xapi') &&
+    adapter instanceof BaseXAPILaunchAdapter
+  ) {
     const inner = adapter.getPublisher();
     if (!inner) return null;
     try {

package/src/virtual.d.ts

@@ -7,7 +7,10 @@ declare module 'virtual:tessera-layout' {
 declare module 'virtual:tessera-adapter' {
   import type { PersistenceAdapter } from 'tessera-learn/runtime/persistence.js';
   import type { CourseConfig } from 'tessera-learn/runtime/types.js';
-  export function createAdapter(config: CourseConfig): PersistenceAdapter;
+  export function createAdapter(
+    config: CourseConfig,
+    options?: { manifest?: unknown; allowFallback?: boolean },
+  ): PersistenceAdapter;
 }
 
 declare module 'virtual:tessera-xapi-setup' {

package/templates/course/course.config.js

@@ -1,5 +1,6 @@
 export default {
   title: '__PROJECT_TITLE__',
+  id: '__COURSE_ID__',
   language: 'en',
   navigation: { mode: 'free' },
   completion: { mode: 'percentage', percentageThreshold: 100 },