@pie-players/pie-section-player 0.3.67 → 0.3.68

package/dist/components/shared/section-player-host-runtime.d.ts

@@ -75,11 +75,15 @@ export declare function resolveSectionPlayerRuntimeState(args: RuntimeInputs): {
     };
 };
 /**
- * Fold a layout element's `nds-icons` convenience attribute into the
- * `runtime` config handed to the kernel. Only injects when the attribute
- * is explicitly set, so an unset attribute never clobbers a
- * `runtime.ndsIcons` the host provided; when both are present,
- * `runtime.ndsIcons` wins (spread last). Returns the input unchanged when
- * the attribute is unset.
+ * Fold a layout element's presentation convenience attributes — `nds-icons` and
+ * `locale` — into the `runtime` config handed to the kernel.
+ *
+ * Only injects an attribute that is explicitly set, so an unset one never
+ * clobbers a value the host put on `runtime`; when both are present, `runtime`
+ * wins (spread last). Returns the input unchanged when neither is set, which
+ * keeps `kernelRuntime` referentially stable for a host that supplies neither.
  */
-export declare function mergeNdsIconsIntoRuntime(runtime: RuntimeConfig | null, ndsIcons: boolean | undefined): RuntimeConfig | null;
+export declare function mergeLayoutAttrsIntoRuntime(runtime: RuntimeConfig | null, attrs: {
+    ndsIcons?: boolean;
+    locale?: string;
+}): RuntimeConfig | null;

package/dist/components/shared/section-player-shell-layout.svelte.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The layout plumbing every section-player custom-element shell needs.
+ *
+ * The three shells — vertical, tabbed, split-pane — differ in how they arrange
+ * panes and in nothing else at this level: each clamps the same host-configurable
+ * pixel values, finds its own host element through the same root-node walk, and
+ * watches the same narrow-layout media query. That was copied three times, so a
+ * changed clamp bound reached whichever shells someone remembered.
+ *
+ * What cannot be shared, and is not this module's failure: the `props` map inside
+ * `<svelte:options customElement={{…}}>`. The Svelte compiler rejects anything but
+ * a statically analyzable object literal there — `svelte_options_invalid_customelement_props`
+ * — so that block stays duplicated per shell by construction. The command
+ * forwarders are the same story: the compiler exposes a component's
+ * `export function` declarations as custom-element methods, so they must be
+ * declared in each `.svelte` file, though their bodies are one line each.
+ */
+export declare const DEFAULT_NARROW_BREAKPOINT_PX = 1100;
+/**
+ * A host-supplied pixel value, clamped into range. `undefined` for anything the
+ * host left unset or wrote as a non-number, so a caller can fall back rather than
+ * render at zero.
+ */
+export declare function resolveConfiguredPx(value: unknown, min: number, max: number): number | undefined;
+/** The narrow-layout breakpoint, clamped, defaulting when the host set nothing. */
+export declare function clampNarrowBreakpoint(value: unknown): number;
+/**
+ * The two content-width caps, clamped.
+ *
+ * `withPassage` is floored at `noPassage`: a passage adds a column, so the
+ * two-column cap narrower than the one-column cap would shrink the content on
+ * the wider layout.
+ */
+export declare function resolveContentMaxWidths(contentMaxWidthNoPassage: unknown, contentMaxWidthWithPassage: unknown): {
+    noPassagePx: number | undefined;
+    withPassagePx: number | undefined;
+};
+/**
+ * The custom element hosting this shell, reached from the shell's anchor node.
+ *
+ * Through `getRootNode` so it works whether the shell renders into a shadow root
+ * or into light DOM, which these shells do (`shadow: "none"`, so item-player and
+ * runtime styles can cascade into rendered item content).
+ */
+export declare function getShellHostElement(anchor: HTMLElement | null): HTMLElement | null;
+/**
+ * Track whether the viewport is below the shell's narrow-layout breakpoint.
+ *
+ * Call from a component's init; the effect it registers is torn down with that
+ * component. `getBreakpoint` is read reactively, so a host changing the
+ * breakpoint attribute re-subscribes to the new query.
+ */
+export declare function createNarrowLayoutWatch(getBreakpoint: () => number): {
+    readonly isNarrow: boolean;
+};

package/dist/components/shared/section-player-view-state.d.ts

@@ -1,4 +1,5 @@
 import { ItemEntity } from '@pie-players/pie-players-shared/types';
+import { FormativeItemView } from '@pie-players/pie-players-shared/formative';
 import { SectionCompositionModel } from '../../controllers/types.js';
 import { PlayerElementParams } from './player-action.js';
 /**
@@ -52,6 +53,39 @@ export declare function getPassagePlayerParams(args: {
     playerStrategy: string;
     baseHeadingLevel?: HeadingLevel;
 }): PlayerElementParams;
+/**
+ * The formative view for one item, or `null` when the section does not deliver
+ * formatively.
+ *
+ * Derived here rather than in a component so the card, the env projection, and
+ * any future consumer read one predicate. The projection arrives on the
+ * composition model, which the runtime republishes on every controller event, so
+ * this is recomputed from fresh state on each render pass.
+ */
+export declare function getFormativeItemView(args: {
+    compositionModel: SectionCompositionModel;
+    canonicalItemId: string;
+}): FormativeItemView | null;
+/**
+ * What a card needs to know about the cue timeline, or `null` when the section is
+ * not timed media.
+ *
+ * Derived here rather than in a component for the same reason the formative view
+ * is: two derivations of one predicate can disagree about whether an item is on
+ * screen.
+ */
+export interface TimedMediaItemView {
+    /** Awaiting its cue. Kept mounted; see `SectionItemsPane`. */
+    pending: boolean;
+    /** This item is what a currently held gate is waiting for. */
+    isGateTarget: boolean;
+    /** The gate is enforced rather than advisory — playback is really stopped. */
+    gateEnforced: boolean;
+}
+export declare function getTimedMediaItemView(args: {
+    compositionModel: SectionCompositionModel;
+    canonicalItemId: string;
+}): TimedMediaItemView | null;
 export declare function getItemPlayerParams(args: {
     item: ItemEntity;
     compositionModel: SectionCompositionModel;
@@ -61,6 +95,7 @@ export declare function getItemPlayerParams(args: {
     playerStrategy: string;
     itemIndex?: number;
     baseHeadingLevel?: HeadingLevel;
+    formativeView?: FormativeItemView | null;
 }): PlayerElementParams;
 export declare function getCanonicalItemId(args: {
     compositionModel: SectionCompositionModel;

package/dist/components/shared/use-interface-i18n.svelte.d.ts

@@ -0,0 +1,20 @@
+import { I18nProvider, InterpolationValues, MessageKeyInput, PluralOptions, TextDirection } from '@pie-players/pie-players-shared/i18n/types';
+export interface InterfaceI18n {
+    /** The resolved provider: the published one, or the English-only default. */
+    readonly provider: I18nProvider;
+    /** Active locale tag, for stamping `lang`. */
+    readonly locale: string;
+    /** Writing direction, for stamping `dir`. */
+    readonly direction: TextDirection;
+    t(key: MessageKeyInput, values?: InterpolationValues): string;
+    plural(key: MessageKeyInput, options: PluralOptions): string;
+}
+/**
+ * Resolve the interface-locale provider for a component.
+ *
+ * @param getHost Returns the element to make the context request from. Any
+ *   element inside the player works: requests bubble to the toolkit's provider.
+ *   Returning `undefined` before the element is bound is expected, and the
+ *   connection is made when it appears.
+ */
+export declare function useInterfaceI18n(getHost: () => HTMLElement | null | undefined): InterfaceI18n;

package/dist/controllers/SectionController.d.ts

@@ -1,4 +1,6 @@
 import { TestAttemptSession } from '@pie-players/pie-assessment-toolkit';
+import { FormativeSectionProjection } from '@pie-players/pie-players-shared/formative';
+import { MediaTimeSource, TimedMediaSectionProjection } from '@pie-players/pie-players-shared/timed-media';
 import { SectionControllerHandle, SectionSessionPersistenceConfig, SectionControllerRuntimeState, SectionControllerSessionState } from './toolkit-section-contracts.js';
 import { ItemEntity } from '@pie-players/pie-players-shared';
 import { NavigationResult, SectionControllerChangeListener, SectionCompositionModel, SectionNavigationState, SectionViewModel, SessionChangedResult } from './types.js';
@@ -21,6 +23,19 @@ export declare class SectionController implements SectionControllerHandle {
     private nextApplyRevision;
     private lastReplayedApplyRevision;
     private pendingApplyReplay;
+    private formativePolicies;
+    private formativeStates;
+    private formativeEnabled;
+    private lastMasterySignature;
+    private timedMediaData;
+    private timedMediaState;
+    private mediaTimeSource;
+    private mediaTimeSourceOrigin;
+    private unsubscribeMediaTimeSource;
+    private lastTimedMediaSignature;
+    private lastTimedMediaInvalidSignature;
+    private reportedDegradationKeys;
+    private mediaAttachWatch;
     private emitChange;
     subscribe(listener: SectionControllerChangeListener): () => void;
     initialize(input?: unknown): Promise<void>;
@@ -49,7 +64,166 @@ export declare class SectionController implements SectionControllerHandle {
      * This is intentionally compact and not a full runtime diagnostics view.
      */
     getSession(): SectionControllerSessionState | null;
+    private rebuildFormativePolicies;
+    private computeMastery;
+    getFormativeProjection(): FormativeSectionProjection | null;
+    /**
+     * Record one Try from element outcomes.
+     *
+     * Correctness derivation lives here rather than at the call site so one
+     * aggregation policy applies to every caller. The reducer is a no-op when the
+     * item cannot currently be checked, which is what makes a double submit safe
+     * — a second click landing before the composition republishes is dropped
+     * rather than spending a Try.
+     */
+    recordFormativeTry(args: {
+        itemId: string;
+        outcomes?: unknown[];
+    }): void;
+    /** Dismiss a reveal and reopen the item, withdrawing its env projection. */
+    retryFormativeItem(args: {
+        itemId: string;
+    }): void;
+    /**
+     * Reveal on host authority — a teacher-driven "show the answer". Spends no
+     * Try and ignores the Try budget.
+     */
+    revealFormativeItem(args: {
+        itemId: string;
+        feedback: "correctness" | "solution";
+    }): void;
+    /** Withdraw a reveal on host authority, Try budget notwithstanding. */
+    hideFormativeItem(args: {
+        itemId: string;
+    }): void;
+    /**
+     * Store a reveal transition and announce it. Shared by the three callers so
+     * one event describes every reveal change a Try did not cause.
+     */
+    private commitFormativeReveal;
+    /**
+     * Emit only on a rollup change, matching how
+     * `section-items-complete-changed` gates on the aggregate rather than on
+     * every intermediate count.
+     */
+    private emitMasteryIfChanged;
     private getSectionItemIdentifiers;
+    private rebuildTimedMedia;
+    /**
+     * Report malformed authored data once per distinct failure.
+     *
+     * `initialize` runs again on every same-cohort `updateInput`, and a PnP toggle
+     * must not re-report a section's authoring defect each time.
+     */
+    private reportTimedMediaInvalid;
+    /**
+     * The live projection, uncloned and for internal readers only.
+     *
+     * Resolving is cheap and runs on every `timeupdate`; deep-cloning it there was
+     * not. `delivery` is threaded in where the caller already has it, because
+     * assembling it walks every item in the section.
+     */
+    private resolveTimedMediaView;
+    /** The public boundary, so this is where the copy is made. */
+    getTimedMediaProjection(): TimedMediaSectionProjection | null;
+    /**
+     * The delivery state cue gates read, assembled from state this controller
+     * already keeps: completion answers `"responded"`, and the last Try's
+     * correctness answers the correctness conditions. A gate on `"responded"`
+     * therefore works in a section that does not deliver formatively at all.
+     */
+    private getTimedMediaDeliveryState;
+    /**
+     * Bind the Media Time Source. Called by the stimulus card with a native adapter,
+     * and directly by a host supplying its own port — which is what lets a host
+     * deliver timed media without shipping a PIE element.
+     */
+    attachMediaTimeSource(source: MediaTimeSource, options?: {
+        origin?: "native-adapter" | "host";
+        renderableId?: string;
+    }): void;
+    detachMediaTimeSource(options?: {
+        origin?: "native-adapter" | "host";
+    }): void;
+    /**
+     * Watch for a stimulus that resolves but never exposes a time source.
+     *
+     * Armed once the section's content has loaded, and only while no source is
+     * attached — which is already the common case, because the stimulus card
+     * registers its adapter as soon as the media element appears in its subtree.
+     */
+    private armMediaAttachWatch;
+    private clearMediaAttachWatch;
+    /**
+     * The stimulus resolved to a renderable that exposes no media, so no cue can
+     * ever fire and every cued item would stay hidden for the whole session.
+     *
+     * Handled exactly as malformed `timedMedia` is: the timeline is dropped, the
+     * section delivers as an ordinary section with every item visible, and the
+     * defect is reported non-recoverably. Same outcome, same posture — refusing to
+     * deliver would turn one authoring slip into a blank section, and leaving the
+     * timeline in place would keep the items hidden behind cues nothing can fire.
+     */
+    private reportStimulusExposesNoTimeSource;
+    /**
+     * Move a freshly attached source up to the restored position, forward only so it
+     * never fights a learner who has already scrubbed — the same rule the signing
+     * region applies when it seeks a fragment on `loadedmetadata`.
+     */
+    private syncMediaPositionFromState;
+    /**
+     * One step of the cue reduction: fold the input into cue state, drive the port
+     * with whatever the reduction asked for, and emit only when cue state moved.
+     */
+    private advanceTimedMedia;
+    /**
+     * Silence media audio so another audio owner can speak.
+     *
+     * The handoff rule the contract's accessibility requirements name, reduced to
+     * the half the section can carry out: the section owns the port, so it can stop
+     * media audio, and it owns no read-aloud, so it decides nothing about speech.
+     * Whoever holds both — the toolkit — calls this and yields the other way on
+     * `timed-media-audio-started`.
+     *
+     * Returns whether media audio is now silent, which is `false` only for a source
+     * that is playing and reports no `canPause`. The overlap then stands: refusing
+     * to speak would withhold an accommodation to protect a policy the port already
+     * said it cannot keep, so enforcement degrades here exactly as it does for a
+     * gate — advisory, and reported at attach.
+     *
+     * No pause is issued for a source already paused, so calling this repeatedly
+     * costs nothing and never fights a learner.
+     */
+    pauseMediaForCompetingAudio(): boolean;
+    /** Announce media audio only where playback actually stood. */
+    private announceMediaAudioStarted;
+    /**
+     * Carry out an effect only where the port reports the capability for it.
+     *
+     * Skipping silently is the failure this contract names: the skip is already
+     * reported once per attach by `reportTimedMediaDegradations`, and the projection
+     * carries `enforcement: "advisory"` for as long as the gap lasts.
+     */
+    private applyTimedMediaEffects;
+    /**
+     * Report a capability gap once per attached source.
+     *
+     * Enforcement rather than the whole projection: the degradation list is all this
+     * needs, and resolving a projection to read one field of it also paid for a gate
+     * view and two id sets.
+     */
+    private reportTimedMediaDegradations;
+    /**
+     * Emit on cue state, never on the clock.
+     *
+     * `timedMediaProjectionSignature` is shared with the toolkit's composition
+     * revision key rather than restated here: two encodings of "what changes what a
+     * layout renders" drift silently, and the failure is an emit the toolkit
+     * coalesces away or a republish this never announced.
+     */
+    private emitTimedMediaIfChanged;
+    /** Re-evaluate gates after the state a gate condition reads has changed. */
+    private notifyTimedMediaDeliveryChanged;
     /**
      * Runtime/debugger shape scoped to the current section.
      * Use this for widgets that need a section-scoped live snapshot (debug panels, diagnostics).

package/dist/controllers/types.d.ts

@@ -1,6 +1,8 @@
 import { TestAttemptSession } from '@pie-players/pie-assessment-toolkit';
 import { ItemSessionUpdateIntent, AssessmentItemRef, AssessmentSection, ItemEntity, PassageEntity, RubricBlock } from '@pie-players/pie-players-shared';
 import { ConfigContainerEntity } from '@pie-players/pie-players-shared/types';
+import { FormativeFeedbackReveal, FormativeItemPolicy, FormativeMasteryRollup, FormativeSectionProjection, FormativeSectionSlice, FormativeTryOutcome } from '@pie-players/pie-players-shared/formative';
+import { TimedMediaDegradation, TimedMediaSectionProjection, TimedMediaSectionSessionSlice, TimedMediaValidationError } from '@pie-players/pie-players-shared/timed-media';
 export type SectionView = "candidate" | "scorer" | "author" | "proctor" | "testConstructor" | "tutor";
 export interface SectionContentModel {
     passages: PassageEntity[];
@@ -14,7 +16,24 @@ export interface SectionContentModel {
             id?: string;
             identifier?: string;
         };
+        /**
+         * The item ref's formative override, carried through because this
+         * projection is where the canonical identifier is decided. Resolving
+         * policy from the raw `assessmentItemRefs` instead would mean recomputing
+         * that identifier, and two implementations of one mapping.
+         */
+        formative?: FormativeItemPolicy;
     }>;
+    /**
+     * How an authored `timedMedia.stimulusRef` resolves to a renderable.
+     *
+     * Keyed by every spelling a section may reference the stimulus under — the
+     * rubric block identifier, the authored passage id, and the normalized id —
+     * mapping to the normalized passage id the renderables carry. Empty for a
+     * section with no stimulus rubric block, which is what makes an unresolvable
+     * `stimulusRef` detectable rather than silently cue-less.
+     */
+    stimulusRenderableIdsByRef: Record<string, string>;
 }
 export type SectionRenderableFlavor = "item" | "passage" | "rubric";
 export interface SectionRenderable {
@@ -35,6 +54,8 @@ export interface SectionSessionState {
     currentItemIndex?: number;
     visitedItemIdentifiers?: string[];
     itemSessions: Record<string, unknown>;
+    formative?: FormativeSectionSlice;
+    timedMedia?: TimedMediaSectionSessionSlice;
 }
 export interface SectionViewModel extends SectionContentModel {
     currentItemIndex: number;
@@ -70,6 +91,26 @@ export interface SectionCompositionModel {
     itemSessionsByItemId: Record<string, unknown>;
     testAttemptSession: TestAttemptSession | null;
     itemViewModels: SectionCanonicalItemViewModel[];
+    /**
+     * Formative delivery projection, keyed by canonical item id. Absent reads
+     * exactly as `null`: no item in the section delivers formatively, which is
+     * every section authored without a `formative` policy. Optional so anything
+     * else assembling this model — a host layout, a test double — omits the
+     * field instead of declaring a feature it does not use.
+     *
+     * Layouts read it from here rather than calling the controller: the runtime
+     * republishes the composition model on every controller event, so a recorded
+     * Try reaches the cards through the channel that already exists.
+     */
+    formative?: FormativeSectionProjection | null;
+    /**
+     * Timed-media projection: cues, enforcement, which items a cue has revealed,
+     * and the gate holding playback. `null` for every section that is not timed
+     * media, and for one whose `timedMedia` failed validation — a layout that reads
+     * `null` renders exactly as it does today, which is what keeps the addition
+     * invisible to existing content.
+     */
+    timedMedia?: TimedMediaSectionProjection | null;
 }
 export interface SectionCanonicalItemViewModel {
     item: ItemEntity;
@@ -144,7 +185,7 @@ export interface SectionNavigationState {
 }
 export type SectionContentKind = "item" | "passage" | "rubric" | "unknown";
 interface SectionControllerEventBase {
-    type: "item-session-data-changed" | "item-session-meta-changed" | "item-selected" | "section-navigation-change" | "section-session-applied" | "content-loaded" | "item-player-error" | "item-complete-changed" | "section-loading-complete" | "section-items-complete-changed" | "section-error";
+    type: "item-session-data-changed" | "item-session-meta-changed" | "item-selected" | "section-navigation-change" | "section-session-applied" | "content-loaded" | "item-player-error" | "item-complete-changed" | "section-loading-complete" | "section-items-complete-changed" | "section-error" | "formative-try-recorded" | "formative-reveal-changed" | "section-mastery-changed" | "timed-media-cue-changed" | "timed-media-audio-started" | "timed-media-policy-degraded" | "timed-media-invalid";
     timestamp: number;
 }
 interface ItemScopedControllerEventBase extends SectionControllerEventBase {
@@ -229,6 +270,91 @@ export interface SectionErrorEvent extends ItemScopedControllerEventBase {
     canonicalItemId?: string;
     contentKind?: SectionContentKind;
 }
-export type SectionControllerChangeEvent = ItemSessionDataChangedEvent | ItemSessionMetaChangedEvent | ItemSelectedEvent | SectionNavigationChangeEvent | SectionSessionAppliedEvent | ContentLoadedEvent | ItemPlayerErrorEvent | ItemCompleteChangedEvent | SectionLoadingCompleteEvent | SectionItemsCompleteChangedEvent | SectionErrorEvent;
+export interface FormativeTryRecordedEvent extends ItemScopedControllerEventBase {
+    type: "formative-try-recorded";
+    itemId: string;
+    canonicalItemId: string;
+    tryCount: number;
+    outcome: FormativeTryOutcome;
+    revealed: boolean;
+}
+/**
+ * The reveal state changed without a Try being recorded: a learner dismissed
+ * feedback to edit again, or a host forced a reveal or withdrew one. A Try that
+ * reveals reports through `formative-try-recorded`.
+ */
+export interface FormativeRevealChangedEvent extends ItemScopedControllerEventBase {
+    type: "formative-reveal-changed";
+    itemId: string;
+    canonicalItemId: string;
+    revealed: boolean;
+    /** Reveal level in force, when a host overrode the policy's. */
+    feedback?: FormativeFeedbackReveal;
+    /** Tries already spent; none of these transitions consume one. */
+    tryCount: number;
+    source: "learner" | "host";
+}
+export interface SectionMasteryChangedEvent extends ItemScopedControllerEventBase {
+    type: "section-mastery-changed";
+    mastery: FormativeMasteryRollup;
+}
+/**
+ * Cue state changed: a cue activated, a gate released, or aggregate completion
+ * flipped.
+ *
+ * Media position is deliberately not an event. `timeupdate` fires about four
+ * times a second and changes nothing a layout renders — the media element draws
+ * its own clock — so position lives in the session slice and surfaces here only
+ * through the cue transitions it caused. Emitting per tick would republish the
+ * composition four times a second for no visible change.
+ */
+export interface TimedMediaCueChangedEvent extends ItemScopedControllerEventBase {
+    type: "timed-media-cue-changed";
+    /** The cue that activated in this transition, where one did. */
+    activatedCueIdentifier?: string;
+    /** The gate that released in this transition, where one did. */
+    releasedCueIdentifier?: string;
+    activeCueIdentifier?: string;
+    visitedCueIdentifiers: string[];
+    completedCueIdentifiers: string[];
+    revealedItemIds: string[];
+    gateCueIdentifier: string | null;
+    mediaCompleted: boolean;
+    aggregateComplete: boolean;
+}
+/**
+ * Media audio is now running, so any other audio owner must yield.
+ *
+ * The section owns no audio but the port, and no policy over read-aloud, so this
+ * announces rather than decides: the toolkit holds both capabilities and arbitrates
+ * between them. Emitted only where playback actually stood — a gate that re-paused
+ * on the same `play` produced no audio, and silencing read-aloud for it would take
+ * an accommodation away for nothing.
+ *
+ * Carries no payload. "Media audio started" is the whole fact; position and cue
+ * state travel on `timed-media-cue-changed`.
+ */
+export interface TimedMediaAudioStartedEvent extends ItemScopedControllerEventBase {
+    type: "timed-media-audio-started";
+}
+/**
+ * A playback policy the attached media time source cannot carry out. Cues still
+ * fire and state is still recorded; enforcement is what degrades, and it says so
+ * rather than appearing to hold.
+ */
+export interface TimedMediaPolicyDegradedEvent extends ItemScopedControllerEventBase {
+    type: "timed-media-policy-degraded";
+    degradations: TimedMediaDegradation[];
+}
+/**
+ * Authored `timedMedia` this section cannot deliver. The section still renders as
+ * an ordinary section with every item visible; cues that silently never fire is
+ * the outcome this reports instead of producing.
+ */
+export interface TimedMediaInvalidEvent extends ItemScopedControllerEventBase {
+    type: "timed-media-invalid";
+    errors: TimedMediaValidationError[];
+}
+export type SectionControllerChangeEvent = ItemSessionDataChangedEvent | ItemSessionMetaChangedEvent | ItemSelectedEvent | SectionNavigationChangeEvent | SectionSessionAppliedEvent | ContentLoadedEvent | ItemPlayerErrorEvent | ItemCompleteChangedEvent | SectionLoadingCompleteEvent | SectionItemsCompleteChangedEvent | SectionErrorEvent | FormativeTryRecordedEvent | FormativeRevealChangedEvent | SectionMasteryChangedEvent | TimedMediaCueChangedEvent | TimedMediaAudioStartedEvent | TimedMediaPolicyDegradedEvent | TimedMediaInvalidEvent;
 export type SectionControllerChangeListener = (event: SectionControllerChangeEvent) => void;
 export {};