@pie-players/pie-section-player 0.3.74 → 1.0.0-beta.0

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

@@ -306,44 +306,20 @@ 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"
-      },
+      initFailed: "Voorlezen kon niet worden gestart. Probeer het opnieuw.",
       inline: {
         controlsA11y: "Voorleesknoppen",
         playbackSpeedA11y: "Voorleessnelheid",
         rewindA11y: "Terugspoelen",
         fastForwardA11y: "Vooruitspoelen",
         stopA11y: "Voorlezen stoppen",
-        initializing: "Voorlezen wordt gestart",
-        initFailed: "Voorlezen kon niet worden gestart. Probeer het opnieuw.",
         starting: "Voorlezen wordt gestart",
         started: "Voorlezen gestart",
         resumed: "Voorlezen hervat",
         pausedAnnouncement: "Voorlezen gepauzeerd",
         stopped: "Voorlezen gestopt",
         switchedSection: "Het voorlezen is naar een ander onderdeel gegaan",
+        nothingToRead: "Hier is niets om voor te lezen",
         startFailed: "Voorlezen kon niet worden gestart",
         skippedForward: "Vooruitgespoeld",
         skipForwardFailed: "Vooruitspoelen is niet gelukt",
@@ -423,6 +399,7 @@ var e = {
     pnp: {
       title: "PNP-profiel",
       noAssessmentBound: "Geen toets gekoppeld",
+      noAssessmentBoundBody: "Profiel-, district- en afnamebeleid hebben niets om te lezen, dus alleen de requiredTools van een item kunnen een voorziening toekennen. Geef de toets door aan de assessment-eigenschap van de toolkit, of roep updateAssessment(...) aan op de toolkit-coordinator.",
       determinationReadOnly: "Vaststelling (alleen lezen)",
       toolsEditor: "Hulpmiddelen bewerken",
       enforcement: "PNP-handhaving",
@@ -435,6 +412,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: {
@@ -497,12 +475,39 @@ var e = {
       previewEnterText: "Voer eerst voorbeeldtekst in.",
       previewUnavailable: "Een voorbeeld is niet mogelijk zolang deze dienst niet beschikbaar is.",
       browserSynthesisUnavailable: "Spraaksynthese van de browser is niet beschikbaar.",
-      browserSynthesisEndedEarly: "De spraaksynthese van de browser stopte voordat de audio begon. Start de browser opnieuw en probeer het nog eens.",
-      browserSynthesisQueueFailed: "De spraaksynthese van de browser kon het voorbeeldfragment niet in de wachtrij zetten.",
-      browserPreviewFailed: "Het voorbeeld van de browserstem kon niet worden afgespeeld.",
       ssmlWordTrackingDisabled: "Bij een Google SSML-voorbeeld blijft de SSML uit de bron intact, waardoor woordmarkering is uitgeschakeld.",
       applyUnavailable: "Instellingen toepassen is niet mogelijk zolang deze dienst niet beschikbaar is.",
-      coordinatorUnavailable: "De toolkitcoördinator is niet beschikbaar voor voorleesinstellingen."
+      coordinatorUnavailable: "De toolkitcoördinator is niet beschikbaar voor voorleesinstellingen.",
+      customProviderNotRegistered: "Aangepaste provider '{id}' is niet geregistreerd.",
+      customProviderNoConfig: "Aangepaste provider '{id}' gaf geen configuratie om toe te passen.",
+      httpError: "HTTP {status}: {message}",
+      unknownError: "Onbekende fout",
+      previewRequestFailed: "Het voorbeeldverzoek is mislukt ({status}).",
+      notAvailable: "n.v.t.",
+      voiceLocal: "lokaal",
+      voiceRemote: "extern",
+      voiceBrowserDefault: "browserstandaard",
+      browserAvailable: {
+        one: "Browserspraak beschikbaar ({count} stem gevonden).",
+        other: "Browserspraak beschikbaar ({count} stemmen gevonden)."
+      },
+      pollyAvailable: {
+        one: "AWS Polly beschikbaar ({count} passende stem, engine {engine}).",
+        other: "AWS Polly beschikbaar ({count} passende stemmen, engine {engine})."
+      },
+      googleAvailable: {
+        one: "Google Cloud TTS beschikbaar ({count} passende stem).",
+        other: "Google Cloud TTS beschikbaar ({count} passende stemmen)."
+      },
+      headerRowReservation: "Rij in de itemkop gereserveerd: {state}",
+      speedOptionsHelp: "Vermenigvuldigers, gescheiden door komma's of puntkomma's. Neem 1 op voor Normaal; laat leeg om de snelheidsknoppen te verbergen.",
+      usingSelectedVoice: "Gekozen stem: {voice}",
+      autoVoice: "Beste beschikbare stem (automatisch): {voice}",
+      autoVoiceWaiting: "Beste beschikbare stem (automatisch): wachten op de stemmen van de browser.",
+      previewHintBrowserSsml: "SSML wordt niet ondersteund in het browservoorbeeld.",
+      previewHintGoogleSsml: "SSML blijft intact. Markering uitgeschakeld.",
+      previewHintCustom: "Markering actief wanneer de provider spraakmarkeringen teruggeeft.",
+      previewHintTracking: "Markering actief tijdens het afspelen van het voorbeeld."
     }
   }
 };

package/dist/chunks/{sre-engine-wf9s43gg-f09289c5.js → sre-engine-bj997w4b-891a4cbe.js}

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

package/dist/component-definitions.d.ts

@@ -1,7 +1,5 @@
-export type ComponentModuleLoader = () => Promise<unknown>;
 export interface ComponentDefinition {
     tagName: string;
-    ensureDefined?: ComponentModuleLoader;
     attributes?: Record<string, string>;
     props?: Record<string, unknown>;
 }

package/dist/components/shared/card-media-region.d.ts

@@ -4,10 +4,9 @@
  *
  * Sizing only. Which capability fills the region, and whether it has anything to
  * show, belongs to the capability: the card asks the registry for whatever is
- * registered on the surface below and knows nothing else about it. The
- * signed-alternate resolution that used to live here moved to
- * `@pie-players/pie-tool-sign-language` behind that capability's own
- * `requiresAuthoredContent`.
+ * registered on the surface below and knows nothing else about it.
+ * Signed-alternate resolution lives in `@pie-players/pie-tool-sign-language`,
+ * behind that capability's own `requiresAuthoredContent`.
  */
 /**
  * Host slot for media docked beside a card's content.

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,34 @@
+import { FrameworkErrorModel } from '@pie-players/pie-assessment-toolkit';
+import { CohortKey } from '@pie-players/pie-assessment-toolkit/runtime/engine';
+/**
+ * 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, and neither does a `cohort` error that names another
+ * section: that section failed after the learner left it.
+ *
+ * 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" | "cohort"> | null | undefined, coordinator: unknown, current: CohortKey | null): 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,10 @@
 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.
- */
-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/player-preload.d.ts

@@ -46,16 +46,11 @@ export declare class PreloadStageError extends Error {
     constructor(stage: PreloadStage, cause: unknown);
 }
 export declare function getPreloadLogger(componentTag: string): import('@pie-players/pie-players-shared').PieLogger;
-/** The element view the item players render, which pre-warm has to match. */
-export declare function getLoaderView(props: Record<string, unknown>, env: Record<string, unknown>): string;
 /**
- * Stable string signature of a list of renderables, used as a react-key
- * hint for the composition snapshot plumbed through the layout tree.
- *
- * The signature is *not* used for preload dedup anymore — the deep
- * `ElementLoader` primitive handles that internally. It is retained only
- * because downstream template props still pass a string identifier
- * through the customElement boundary.
+ * Stable string signature of a list of renderables: id, version and element
+ * set of each entry's `entity`. The layout composition snapshot carries it,
+ * and the kernel matches the items pane's warmup report against it, so a
+ * report counts only for the composition it was made for.
  */
 export declare function getRenderablesSignature(renderables: unknown[]): string;
 export declare function formatElementLoadError(stage: string, error: unknown): string;

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

@@ -5,11 +5,12 @@ export type SectionPlayerCardRenderContext = {
     playerAction: (node: HTMLElement, params: PlayerElementParams) => unknown;
     cardTitleFormatter?: SectionPlayerCardTitleFormatter;
 };
-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,
@@ -14,21 +14,22 @@ export declare function resolvePlayerRuntime(args: {
     env: Record<string, unknown> | null;
 }): {
     effectivePlayerType: string;
-    resolvedPlayerDefinition: import('../../component-definitions.js').ComponentDefinition;
     resolvedPlayerTag: string;
     resolvedPlayerAttributes: Record<string, string>;
     resolvedPlayerProps: {
         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,39 +52,49 @@ 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;
         resolvedPlayerTag: string;
         resolvedPlayerAttributes: Record<string, string>;
         resolvedPlayerProps: {
             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';
@@ -42,7 +42,6 @@ export type LayoutCompositionSnapshot = {
     renderables: ItemEntity[];
     renderablesSignature: string;
 };
-export declare function getCompositionFromEvent(event: Event): SectionCompositionModel;
 export declare function deriveLayoutCompositionSnapshot(compositionModel: SectionCompositionModel): LayoutCompositionSnapshot;
 export declare function getCompositionSnapshotFromEvent(event: Event): LayoutCompositionSnapshot;
 export declare function getPassagePlayerParams(args: {
@@ -101,3 +100,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;