@pie-players/pie-section-player 0.3.74 → 0.3.75

package/dist/chunks/nl-NL-364d61b9.js

@@ -306,30 +306,6 @@ var e = {
     textToSpeech: {
       name: "Voorlezen",
       description: "Inhoud laten voorlezen",
-      toolA11y: "Voorleeshulp",
-      title: "Voorlezen",
-      initializing: "Wordt gestart…",
-      initFailed: "Voorlezen kon niet worden gestart.",
-      selectText: "Selecteer tekst op de pagina om die te laten voorlezen.",
-      speed: "Snelheid:",
-      play: "Voorlezen",
-      pause: "Pauzeren",
-      resume: "Hervatten",
-      stop: "Stoppen",
-      speaking: "Aan het voorlezen…",
-      paused: "Gepauzeerd",
-      charactersSelected: {
-        one: "{count} teken geselecteerd",
-        other: "{count} tekens geselecteerd"
-      },
-      rate: {
-        slow: "Langzaam",
-        slower: "Langzamer",
-        normal: "Normaal",
-        faster: "Sneller",
-        fast: "Snel",
-        veryFast: "Zeer snel"
-      },
       inline: {
         controlsA11y: "Voorleesknoppen",
         playbackSpeedA11y: "Voorleessnelheid",
@@ -435,6 +411,7 @@ var e = {
       resolvedTools: "Toegekende hulpmiddelen (toolkit)",
       provenanceSummary: "Overzicht van herkomst van het hulpmiddelenbeleid",
       perToolDecisions: "Beslissingen per hulpmiddel",
+      policyDiagnostics: "Diagnose van het hulpmiddelenbeleid",
       profileReadOnly: "PNP-profiel (alleen lezen)"
     },
     tts: {

package/dist/chunks/{sre-engine-wf9s43gg-f09289c5.js → sre-engine-jd8cc08x-42d270e5.js}

@@ -1,4 +1,4 @@
-import { n as t } from "./ItemToolBar-wr2myaah-1287ba31.js";
+import { n as t } from "./ItemToolBar-jx38w99s-1287ba31.js";
 import * as a from "speech-rule-engine";
 var r = a.default ?? a;
 r.setupEngine(t());

package/dist/components/shared/composition.d.ts

@@ -1,7 +1,9 @@
-import { ItemEntity } from '@pie-players/pie-players-shared/types';
+import { ItemEntity, ItemSettings } from '@pie-players/pie-players-shared/types';
 import { SectionCompositionModel } from '../../controllers/types.js';
 export declare const EMPTY_ITEM_SESSION: Record<string, unknown>;
 export declare const EMPTY_COMPOSITION: SectionCompositionModel;
 export declare function getCanonicalItemIdForItem(compositionModel: SectionCompositionModel, item: ItemEntity): string;
+/** The item's policy settings from its assessment item reference. */
+export declare function getItemSettingsForItem(compositionModel: SectionCompositionModel, item: ItemEntity): ItemSettings | null;
 export declare function getSessionForItem(compositionModel: SectionCompositionModel, item: ItemEntity): unknown;
 export declare function getSessionForItemOrEmpty(compositionModel: SectionCompositionModel, item: ItemEntity): Record<string, unknown>;

package/dist/components/shared/framework-error-latch.d.ts

@@ -0,0 +1,32 @@
+import { FrameworkErrorModel } from '@pie-players/pie-assessment-toolkit';
+/**
+ * The section player's readiness error latch. A non-recoverable framework error
+ * latches the scope its report site set: a `cohort` error fails the section it
+ * was reported for and clears when the cohort rolls; a `runtime` error fails
+ * every later section, since they run on the same coordinator. A recoverable
+ * error latches nothing.
+ *
+ * A toolkit bootstrap failure is a runtime error held against the coordinator
+ * the toolkit had announced when it was reported. It clears when the toolkit
+ * announces a different one, which it builds once the host corrects the input
+ * that failed: the coordinator the failure took down is no longer the one later
+ * sections run on.
+ *
+ * `element-preload` latches nothing either. The items pane reports its warmup
+ * outcome with the composition it was for, and the kernel reads that instead: a
+ * latched event cannot tell which section's warmup failed.
+ */
+export type FrameworkErrorLatch = {
+    readonly cohort: boolean;
+    readonly runtime: boolean;
+    /** The coordinator a bootstrap failure was reported under, while one is latched. */
+    readonly bootstrap: {
+        readonly coordinator: unknown;
+    } | null;
+};
+export declare const CLEAR_FRAMEWORK_ERROR_LATCH: FrameworkErrorLatch;
+export declare function latchFrameworkError(latch: FrameworkErrorLatch, detail: Pick<FrameworkErrorModel, "recoverable" | "scope" | "kind"> | null | undefined, coordinator: unknown): FrameworkErrorLatch;
+export declare function rollFrameworkErrorLatch(latch: FrameworkErrorLatch): FrameworkErrorLatch;
+/** Applied on each `toolkit-ready`, with the coordinator it announces. */
+export declare function announceToolkitCoordinator(latch: FrameworkErrorLatch, coordinator: unknown): FrameworkErrorLatch;
+export declare function isFrameworkErrorLatched(latch: FrameworkErrorLatch): boolean;

package/dist/components/shared/host-element.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The custom element a component renders into, reached from an anchor node at
+ * the top of its template.
+ *
+ * The anchor's parent node: the element itself under `shadow: "none"`, or its
+ * shadow root otherwise. The anchor's root node names the host only in the second
+ * case. A light-DOM element inside another component's shadow root shares that
+ * root, so resolving through `getRootNode()` returned the outer component.
+ */
+export declare function getHostElementFromAnchor(anchor: HTMLElement | null): HTMLElement | null;

package/dist/components/shared/kernel-host-default-body.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The kernel host's default body: its stock arrangement of the panes, present
+ * exactly while the host gives the element no element children of its own.
+ *
+ * Mounted into the element's light DOM, beside any children, where the player's
+ * item content renders in every layout: that is where page styles, the content
+ * stylesheet and the item players' own injected styles reach it. As fallback
+ * content of the shadow root's slot it would sit in the shadow tree, out of their
+ * reach, and stay mounted, hidden, beside a host's own panes.
+ *
+ * Text and comment children do not count, so markup whitespace and a framework's
+ * placeholder comments leave the default in place. Returns the teardown.
+ */
+export declare function attachKernelHostDefaultBody(host: HTMLElement, mountBody: (target: HTMLElement) => () => void): () => void;

package/dist/components/shared/layout-host-methods.d.ts

@@ -1,16 +1,6 @@
-import { SectionControllerHandle } from '@pie-players/pie-assessment-toolkit';
-import { SectionPlayerNavigationSnapshot, SectionPlayerSnapshot } from '../../contracts/runtime-host-contract.js';
-export declare const BOOTSTRAP_READINESS: {
-    readonly phase: "bootstrapping";
-    readonly interactionReady: false;
-    readonly allLoadingComplete: false;
-};
+import { SectionControllerHandle, SectionControllerSessionState } from '@pie-players/pie-assessment-toolkit';
+import { SectionPlayerSnapshot } from '../../contracts/runtime-host-contract.js';
 export declare const BOOTSTRAP_SNAPSHOT: {
-    readonly readiness: {
-        readonly phase: "bootstrapping";
-        readonly interactionReady: false;
-        readonly allLoadingComplete: false;
-    };
     readonly composition: {
         readonly itemsCount: 0;
         readonly passagesCount: 0;
@@ -22,29 +12,24 @@ export declare const BOOTSTRAP_SNAPSHOT: {
         readonly canPrevious: false;
     };
 };
-/** What each read returns before the component mounts. */
-export type UnmountedReads = {
-    snapshot: SectionPlayerSnapshot | null;
-    composition: SectionPlayerSnapshot["composition"] | null;
-    navigation: SectionPlayerNavigationSnapshot | null;
-    readiness: SectionPlayerSnapshot["readiness"] | null;
-};
-export declare const NULL_READS: UnmountedReads;
-export declare const BOOTSTRAP_READS: UnmountedReads;
 /**
- * For a layout element's `customElement.extend`. `unmounted` is what that
- * element's reads return while its kernel is not bound.
+ * For a layout element's `customElement.extend`. `unmountedSnapshot` is what
+ * that element's `getSnapshot` returns while its kernel is not bound.
  */
-export declare function withHostMethods(unmounted: UnmountedReads): <Base extends CustomElementConstructor>(ElementClass: Base) => {
+export declare function withHostMethods(unmountedSnapshot: SectionPlayerSnapshot | null): <Base extends CustomElementConstructor>(ElementClass: Base) => {
     new (...params: any[]): {
         getSnapshot(): SectionPlayerSnapshot | null;
-        selectComposition(): SectionPlayerSnapshot["composition"] | null;
-        selectNavigation(): SectionPlayerNavigationSnapshot | null;
-        selectReadiness(): SectionPlayerSnapshot["readiness"] | null;
         navigateTo(index: number): boolean;
         navigateNext(): boolean;
         navigatePrevious(): boolean;
         getSectionController(): SectionControllerHandle | null;
+        /**
+         * A fresh snapshot on each read once the controller is published. The
+         * item player instead returns the host's own object, kept current by
+         * projection; no host reads a section session by reference.
+         */
+        get session(): SectionControllerSessionState | null;
+        set session(value: SectionControllerSessionState | null);
         waitForSectionController(timeoutMs?: number): Promise<SectionControllerHandle | null>;
         accessKey: string;
         readonly accessKeyLabel: string;

package/dist/components/shared/missing-tool-providers.d.ts

@@ -1,16 +1,16 @@
 import { ToolkitCoordinatorApi, ToolRegistry } from '@pie-players/pie-assessment-toolkit';
 /**
  * Warn once per placed tool whose registration carries a provider the coordinator
- * has not registered. Reads the coordinator's current placement and providers, so
- * call it only once the coordinator reports ready.
+ * has not registered under the tool's id. Reads the coordinator's current
+ * placement and providers, so call it only once the coordinator reports ready.
  */
 export declare function reportMissingToolProviders(coordinator: ToolkitCoordinatorApi, toolRegistry: ToolRegistry): void;
 /**
- * Check `coordinator` now and whenever its policy inputs change, since placement
- * can. A check runs once the coordinator reports ready: its providers have
- * registered by then, and a text-to-speech reconfiguration, which unregisters and
- * re-registers that provider, holds readiness until it is back. Readiness is
- * polled because `waitUntilReady()` would start initialization a lazy
- * coordinator defers, and retry one that failed. Returns the teardown.
+ * Check `coordinator` once it reports ready, and again whenever readiness or its
+ * policy inputs change, since placement can. Its providers have registered by
+ * then, and a text-to-speech reconfiguration, which unregisters and re-registers
+ * that provider, holds readiness until it is back. `waitUntilReady()` is not
+ * awaited: it would start text-to-speech a lazy coordinator defers, and retry
+ * one that failed. Returns the teardown.
  */
 export declare function watchMissingToolProviders(coordinator: ToolkitCoordinatorApi, toolRegistry: ToolRegistry): () => void;

package/dist/components/shared/section-player-backend-delivery.d.ts

@@ -1,5 +1,5 @@
 import { BackendConfig } from '@pie-players/pie-item-player';
-import { PlayerOverrides, RuntimeConfig } from '@pie-players/pie-assessment-toolkit/runtime/internal';
+import { PlayerOverrides, RuntimeConfig } from '@pie-players/pie-assessment-toolkit/runtime/engine';
 import { ItemEntity } from '@pie-players/pie-players-shared/types';
 export type SectionPlayerBackendResolverContext = {
     itemId: string;

package/dist/components/shared/section-player-card-context.d.ts

@@ -8,8 +8,12 @@ export type SectionPlayerCardRenderContext = {
 export declare const sectionPlayerCardRenderContext: {
     __context__: SectionPlayerCardRenderContext;
 };
-export declare function getHostElementFromAnchor(anchor: HTMLElement | null): HTMLElement | null;
 export declare function connectSectionPlayerCardRenderContext(host: HTMLElement, onValue: (value: SectionPlayerCardRenderContext) => void): () => void;
+/**
+ * A card that subscribes before this provider connects is answered through the
+ * document's context root, which replays its request when the provider
+ * announces itself.
+ */
 export declare function createSectionPlayerCardRenderContextProvider(host: HTMLElement, initialValue: SectionPlayerCardRenderContext): {
     setValue: (value: SectionPlayerCardRenderContext) => void;
     disconnect: () => void;

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

@@ -1,4 +1,4 @@
-import { RuntimeConfig, RuntimeInputs } from '@pie-players/pie-assessment-toolkit/runtime/internal';
+import { RuntimeInputs } from '@pie-players/pie-assessment-toolkit/runtime/engine';
 import { ItemEntity } from '@pie-players/pie-players-shared';
 /**
  * Resolve the player-runtime view (player tag, attributes, props,
@@ -21,14 +21,16 @@ export declare function resolvePlayerRuntime(args: {
         loaderOptions: {
             [x: string]: unknown;
         };
-        loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
         hosted: boolean;
+        loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
+        backend?: Record<string, unknown> | null;
     } | {
         loaderOptions: {
             [x: string]: unknown;
         };
+        hosted?: boolean;
         loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
-        hosted?: undefined;
+        backend?: Record<string, unknown> | null;
     };
     resolvedPlayerEnv: Record<string, unknown>;
     strategy: import('@pie-players/pie-players-shared').ItemPlayerStrategy;
@@ -51,7 +53,29 @@ export declare function mapRenderablesToItems(renderables: unknown[]): ItemEntit
  */
 export declare function resolveSectionPlayerRuntimeState(args: RuntimeInputs): {
     effectiveToolsConfig: unknown;
-    effectiveRuntime: import('@pie-players/pie-assessment-toolkit/runtime/internal').EffectiveRuntime;
+    effectiveRuntime: {
+        playerType: string;
+        player: {
+            hosted?: boolean;
+            loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
+            loaderOptions?: Record<string, unknown>;
+            backend?: Record<string, unknown> | null;
+        } | null;
+        lazyInit: boolean;
+        accessibility: Record<string, unknown> | null;
+        coordinator: {} | null;
+        createSectionController: unknown;
+        isolation: string;
+        env: Record<string, unknown>;
+        toolConfigStrictness: import('@pie-players/pie-assessment-toolkit').ToolConfigStrictness;
+        tools: unknown;
+        assessmentId?: string;
+        toolContextResolvers?: Record<string, unknown> | null;
+        contentLanguage?: string;
+        onFrameworkError?: import('@pie-players/pie-assessment-toolkit/runtime/engine').FrameworkErrorHandler;
+        onStageChange?: import('@pie-players/pie-assessment-toolkit/runtime/engine').StageChangeHandler;
+        onLoadingComplete?: import('@pie-players/pie-assessment-toolkit/runtime/engine').LoadingCompleteHandler;
+    };
     playerRuntime: {
         effectivePlayerType: string;
         resolvedPlayerDefinition: import('../../component-definitions.js').ComponentDefinition;
@@ -61,29 +85,18 @@ export declare function resolveSectionPlayerRuntimeState(args: RuntimeInputs): {
             loaderOptions: {
                 [x: string]: unknown;
             };
-            loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
             hosted: boolean;
+            loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
+            backend?: Record<string, unknown> | null;
         } | {
             loaderOptions: {
                 [x: string]: unknown;
             };
+            hosted?: boolean;
             loaderConfig?: import('@pie-players/pie-players-shared').LoaderConfig;
-            hosted?: undefined;
+            backend?: Record<string, unknown> | null;
         };
         resolvedPlayerEnv: Record<string, unknown>;
         strategy: import('@pie-players/pie-players-shared').ItemPlayerStrategy;
     };
 };
-/**
- * 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 mergeLayoutAttrsIntoRuntime(runtime: RuntimeConfig | null, attrs: {
-    ndsIcons?: boolean;
-    locale?: string;
-}): RuntimeConfig | null;

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

@@ -0,0 +1,77 @@
+import { ToolRegistry, ToolbarItem } from '@pie-players/pie-assessment-toolkit';
+import { ItemEntity } from '@pie-players/pie-players-shared/types';
+import { SectionCompositionModel } from '../../controllers/types.js';
+import { ElementPreloadErrorDetail, ElementPreloadRetryDetail } from './player-preload.js';
+import { HeadingLevel } from './section-player-view-state.js';
+export type SectionPlayerPaneKind = "items" | "passages";
+/** Where the items pane's element pre-warm stands. */
+export type SectionPlayerPaneWarmup = "pending" | "loaded" | "failed";
+export type SectionPlayerPaneReport = {
+    warmup: SectionPlayerPaneWarmup;
+    /** The renderables signature the report was made for. */
+    renderablesSignature: string;
+};
+export type SectionPlayerLayoutContext = {
+    /** The layout element's tag, which labels the items pane's preload reports. */
+    componentTag: string;
+    items: SectionCompositionModel["items"];
+    passages: SectionCompositionModel["passages"];
+    compositionModel: SectionCompositionModel;
+    preloadedRenderables: ItemEntity[];
+    preloadedRenderablesSignature: string;
+    preloadEnabled: boolean;
+    resolvedPlayerEnv: Record<string, unknown>;
+    resolvedPlayerAttributes: Record<string, string>;
+    resolvedPlayerProps: Record<string, unknown>;
+    playerStrategy: string;
+    baseHeadingLevel: HeadingLevel;
+    iifeBundleHost: string | null;
+    toolRegistry: ToolRegistry;
+    itemToolbarTools: string;
+    passageToolbarTools: string;
+    itemHostButtons: ToolbarItem[];
+    passageHostButtons: ToolbarItem[];
+    /**
+     * Whether the items pane's element pre-warm has resolved for the current
+     * composition; the passages pane shows its loading card until it has.
+     */
+    elementsLoaded: boolean;
+    /** The pane of each kind that renders. */
+    activePanes: Readonly<Record<SectionPlayerPaneKind, Element | null>>;
+    /** Returns the unregister. */
+    registerPane: (kind: SectionPlayerPaneKind, pane: Element) => () => void;
+    /** Reports from any pane but the active items pane are ignored. */
+    reportWarmup: (pane: Element, report: SectionPlayerPaneReport) => void;
+    reportPreloadRetry: (pane: Element, detail: ElementPreloadRetryDetail) => void;
+    reportPreloadError: (pane: Element, detail: ElementPreloadErrorDetail) => void;
+};
+export declare const sectionPlayerLayoutContext: {
+    __context__: SectionPlayerLayoutContext;
+};
+export declare function connectSectionPlayerLayoutContext(host: HTMLElement, onValue: (value: SectionPlayerLayoutContext) => void): () => void;
+/**
+ * A pane that subscribes before this provider connects is answered through the
+ * document's context root, which replays its request when the provider
+ * announces itself.
+ */
+export declare function createSectionPlayerLayoutContextProvider(host: HTMLElement, initialValue: SectionPlayerLayoutContext): {
+    setValue: (value: SectionPlayerLayoutContext) => void;
+    disconnect: () => void;
+};
+export type SectionPlayerPaneRegistry = {
+    register: (kind: SectionPlayerPaneKind, pane: Element) => () => void;
+    active: () => Record<SectionPlayerPaneKind, Element | null>;
+    dispose: () => void;
+};
+/**
+ * The panes registered with one section player, in registration order.
+ *
+ * `onChange` receives the active pane of each kind after every change. A second
+ * pane of a kind still registered a task later is a layout that renders the
+ * kind twice, reported once per registry through `warn`; the deferral lets a
+ * layout replace a pane without being reported.
+ */
+export declare function createSectionPlayerPaneRegistry(options: {
+    onChange: (active: Record<SectionPlayerPaneKind, Element | null>) => void;
+    warn?: (message: string) => void;
+}): SectionPlayerPaneRegistry;

package/dist/components/shared/section-player-own-event.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether an event that reached a layout host belongs to that section player.
+ *
+ * The runtime engine dispatches its events on the host. The toolkit's
+ * `framework-error` bubbles out of the player's own `<pie-section-player-base>`,
+ * the first one in the host's render root: its light DOM, or the shadow root
+ * of a host that has one, where the event arrives retargeted to the host. An
+ * event from a player nested in an item reaches the host with another target.
+ */
+export declare function isOwnSectionPlayerEvent(event: Event, host: Element): boolean;

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

@@ -1,4 +1,4 @@
-import { LoadingCompleteHandler, StageChangeHandler } from '@pie-players/pie-assessment-toolkit/runtime/internal';
+import { LoadingCompleteHandler, StageChangeHandler } from '@pie-players/pie-assessment-toolkit/runtime/engine';
 export type RuntimeCallbackBridgeChannel = "onStageChange" | "onLoadingComplete";
 export interface RuntimeCallbackBridgeOptions {
     /** Layout CE host element the engine dispatches DOM events on. */

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

@@ -3,9 +3,9 @@
  *
  * 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.
+ * pixel values 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
@@ -35,14 +35,6 @@ export declare function resolveContentMaxWidths(contentMaxWidthNoPassage: unknow
     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.
  *

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

@@ -1,4 +1,4 @@
-import { ItemEntity } from '@pie-players/pie-players-shared/types';
+import { ItemEntity, ItemSettings } 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';
@@ -101,3 +101,8 @@ export declare function getCanonicalItemId(args: {
     compositionModel: SectionCompositionModel;
     item: ItemEntity;
 }): string;
+/** The policy settings the item's card registers through its item scope. */
+export declare function getItemSettings(args: {
+    compositionModel: SectionCompositionModel;
+    item: ItemEntity;
+}): ItemSettings | null;

package/dist/components/shared/toolkit-ready-wait.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The section controller lookups behind `waitForSectionController`.
+ *
+ * The toolkit emits `toolkit-ready` each time it initializes a section, once
+ * that section's controller has resolved: the first section, each switch and
+ * each update to the current one. The event bubbles, composed, through every
+ * element around it.
+ * A wait listens for it on `target` and looks the controller up again each time
+ * it arrives, then once more at the timeout.
+ */
+/**
+ * Resolves with the first controller `lookup` returns after a `toolkit-ready`
+ * reaches `target`, or with what it returns at `timeoutMs`. A `timeoutMs` that
+ * is not finite, or too long for a timer, waits for the event alone.
+ */
+export declare function waitForToolkitReady<Controller>(target: EventTarget | null, lookup: (event?: Event) => Controller | null, timeoutMs: number): Promise<Controller | null>;

package/dist/contracts/host-hooks.d.ts

@@ -10,13 +10,6 @@ import { SectionPlayerCardTitleFormatter } from './card-title-formatters.js';
  * Today the contract has a single member (`cardTitleFormatter`). The shape is
  * intentionally a struct, not a single callback prop, so future host-supplied
  * formatters / decorators can be added without renaming the surface.
- *
- * The naming/expansion of this contract is part of the
- * "Coherent Options Surface" review; the broader expansion (additional hook
- * fields produced as the section host runtime engine consolidates) is owned
- * by the M7 follow-up plan in `coherent_options_surface_review_0133a7cd.plan.md`.
- * Keeping the current name (`SectionPlayerHostHooks`) is deliberate so that
- * additions there do not require a breaking rename across the layout CEs.
  */
 export type SectionPlayerHostHooks = {
     cardTitleFormatter?: SectionPlayerCardTitleFormatter;

package/dist/contracts/runtime-host-contract.d.ts

@@ -1,4 +1,3 @@
-import { SectionPlayerReadinessChangeDetail } from './public-events.js';
 import { SectionControllerHandle } from '@pie-players/pie-assessment-toolkit';
 export type SectionPlayerNavigationSnapshot = {
     currentIndex: number;
@@ -8,7 +7,6 @@ export type SectionPlayerNavigationSnapshot = {
     currentItemId?: string;
 };
 export type SectionPlayerSnapshot = {
-    readiness: SectionPlayerReadinessChangeDetail;
     composition: {
         itemsCount: number;
         passagesCount: number;
@@ -17,9 +15,6 @@ export type SectionPlayerSnapshot = {
 };
 export interface SectionPlayerRuntimeHostContract {
     getSnapshot(): SectionPlayerSnapshot;
-    selectComposition(): SectionPlayerSnapshot["composition"];
-    selectNavigation(): SectionPlayerNavigationSnapshot;
-    selectReadiness(): SectionPlayerReadinessChangeDetail;
     navigateTo(index: number): boolean;
     navigateNext(): boolean;
     navigatePrevious(): boolean;

package/dist/controllers/SectionController.d.ts

@@ -14,6 +14,7 @@ export declare class SectionController implements SectionControllerHandle {
     private readonly listeners;
     private readonly trackedRenderables;
     private readonly loadedRenderableKeys;
+    private readonly heldContentLoads;
     private readonly itemCompletionByCanonicalId;
     private readonly elementCompletionByCanonicalId;
     private readonly reportedCompletionIds;

package/dist/controllers/types.d.ts

@@ -1,6 +1,6 @@
 import { TestAttemptSession } from '@pie-players/pie-assessment-toolkit';
 import { ItemSessionUpdateIntent, SessionCommitReason, AssessmentItemRef, AssessmentSection, ItemEntity, PassageEntity, RubricBlock } from '@pie-players/pie-players-shared';
-import { ConfigContainerEntity } from '@pie-players/pie-players-shared/types';
+import { ConfigContainerEntity, ItemSettings } 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";
@@ -23,6 +23,8 @@ export interface SectionContentModel {
          * that identifier, and two implementations of one mapping.
          */
         formative?: FormativeItemPolicy;
+        /** The item ref's policy settings, carried for the same reason. */
+        settings?: ItemSettings;
     }>;
     /**
      * How an authored `timedMedia.stimulusRef` resolves to a renderable.
@@ -119,6 +121,11 @@ export interface SectionCanonicalItemViewModel {
     index: number;
     isCurrent: boolean;
     session: unknown;
+    /**
+     * The item ref's policy settings, which the item's scope registers; they
+     * govern the item's own toolbar.
+     */
+    settings?: ItemSettings;
 }
 export interface SectionAttemptSessionSliceLoadedRenderable {
     itemId: string;

package/dist/item-section/index.d.ts

@@ -0,0 +1,22 @@
+import { AssessmentSection, ItemConfig, SectionControllerSessionState } from '@pie-players/pie-players-shared/types';
+export interface ItemSectionOptions {
+    /** Defaults to the item config's id. */
+    sectionId?: string;
+    itemVId?: string;
+    /** The item's session, in the shape `<pie-item-player session>` takes. */
+    session?: unknown;
+}
+export interface ItemSection {
+    section: AssessmentSection;
+    session: SectionControllerSessionState | null;
+}
+/**
+ * Build the `section` and `session` a section player layout takes from one item
+ * config and, optionally, its session.
+ *
+ * The item ref's `identifier` and the item's `id` are the config's `id`, so
+ * every `itemId` the section reports is the id the host already holds. The item
+ * and its passage carry no `baseId` or `version`. The host sets `section-id` to
+ * `section.identifier`.
+ */
+export declare function sectionFromItem(config: ItemConfig, options?: ItemSectionOptions): ItemSection;

package/dist/item-section/index.js

@@ -0,0 +1,37 @@
+function d(e) {
+  return !!e.pie;
+}
+function r(e) {
+  const s = { ...e.pie };
+  e.instructorResources !== void 0 && s.instructorResources === void 0 && (s.instructorResources = e.instructorResources), e.defaultExtraModels !== void 0 && s.defaultExtraModels === void 0 && (s.defaultExtraModels = e.defaultExtraModels);
+  const t = {
+    id: e.id,
+    config: s
+  };
+  return e.passage && (t.passage = {
+    id: e.passage.id,
+    config: e.passage
+  }), t;
+}
+function n(e, s = {}) {
+  const t = d(e) ? r(e) : {
+    id: e.id,
+    config: e
+  }, i = {
+    identifier: e.id,
+    item: t
+  };
+  return s.itemVId !== void 0 && (i.itemVId = s.itemVId), {
+    section: {
+      identifier: s.sectionId ?? e.id,
+      assessmentItemRefs: [i]
+    },
+    session: s.session == null ? null : {
+      currentItemIndex: 0,
+      itemSessions: { [e.id]: s.session }
+    }
+  };
+}
+export {
+  n as sectionFromItem
+};

package/dist/pie-section-player.d.ts

@@ -1,10 +1,8 @@
-export type { SectionPlayerLayoutContract, SectionPlayerLayoutName, SectionPlayerLayoutCapability, SectionPlayerBasicPropName, SectionPlayerAdvancedPropName, SectionPlayerLayoutPropName, SectionPlayerLayoutCommandName, } from './contracts/layout-contract.js';
-export type { SectionPlayerPublicEventName, SectionPlayerReadinessPhase, SectionPlayerReadinessChangeDetail, } from './contracts/public-events.js';
-export { SECTION_PLAYER_PUBLIC_EVENTS } from './contracts/public-events.js';
 export type { SectionPlayerRuntimeHostContract, SectionPlayerNavigationSnapshot, SectionPlayerSnapshot, } from './contracts/runtime-host-contract.js';
-export { SPLITPANE_LAYOUT_CONTRACT, TABBED_LAYOUT_CONTRACT, VERTICAL_LAYOUT_CONTRACT, } from './contracts/layout-parity-metadata.js';
-export type { ReadinessPolicyAdapter, SectionPlayerPolicies, SectionPlayerReadinessPolicy, SectionPlayerPreloadPolicy, SectionPlayerTelemetryPolicy, } from './policies/types.js';
-export { DEFAULT_SECTION_PLAYER_POLICIES, isPreloadEnabled, isTelemetryEnabled, } from './policies/index.js';
+export type { SectionPlayerPolicies, SectionPlayerReadinessPolicy, SectionPlayerPreloadPolicy, SectionPlayerTelemetryPolicy, } from './policies/types.js';
+export { DEFAULT_SECTION_PLAYER_POLICIES } from './policies/index.js';
+export { sectionFromItem } from './item-section/index.js';
+export type { ItemSection, ItemSectionOptions } from './item-section/index.js';
 export type { SectionPlayerCardTitleContext, SectionPlayerCardTitleFormatter, SectionPlayerItemTitleContext, SectionPlayerPassageTitleContext, } from './contracts/card-title-formatters.js';
 export type { SectionPlayerHostHooks } from './contracts/host-hooks.js';
 export type { SectionPlayerBackendResolver, SectionPlayerBackendResolverContext, SectionPlayerRuntimeConfig, SectionPlayerRuntimePlayerConfig, } from './components/shared/section-player-backend-delivery.js';