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

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

@@ -2,22 +2,14 @@ import { SectionPlayerCardTitleFormatter } from './card-title-formatters.js';
 /**
  * Host-extension hook contract for the section-player layout custom elements.
  *
- * Hosts pass a `SectionPlayerHostHooks` value via the `host-hooks` attribute
- * (or the `hostHooks` prop, mirroring per the two-tier policy in
- * {@link ../../ARCHITECTURE.md}) on `<pie-section-player-*>` to override
- * formatter / decoration behavior that the engine intentionally leaves to the
- * host. Each hook is optional; omitted hooks fall back to documented defaults.
+ * Hosts pass a `SectionPlayerHostHooks` value as the `hooks` JS property on
+ * `<pie-section-player-*>` to override formatter / decoration behavior that
+ * the engine intentionally leaves to the host. Each hook is optional; omitted
+ * hooks fall back to documented defaults.
  *
  * 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,7 +14,10 @@ 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;
     private sectionLoadingComplete;
     private totalRegistered;
     private totalLoaded;
@@ -254,6 +257,7 @@ export declare class SectionController implements SectionControllerHandle {
     applySession(session: SectionControllerSessionState | null, options?: {
         mode?: "replace" | "merge";
     }): Promise<void>;
+    private applySessionState;
     /**
      * Move between items inside the current section only.
      * Cross-section navigation belongs to the higher-level assessment player.
@@ -295,7 +299,17 @@ export declare class SectionController implements SectionControllerHandle {
     private toSectionContentKind;
     private getRenderableKey;
     private readCompleteFromSession;
+    private sessionHoldsResponse;
+    /**
+     * `restored` names the items a host session was just applied to: what their
+     * elements reported before it describes the session the restore replaced.
+     */
     private bootstrapCompletionFromSessions;
+    /**
+     * The item's completion after one element reports its own. A report that
+     * names no element is the item's completion itself.
+     */
+    private recordElementCompletion;
     private updateItemCompleteState;
     private emitSectionItemsCompleteIfChanged;
     private evaluateSectionLoadingState;

package/dist/controllers/toolkit-section-contracts.d.ts

@@ -1,17 +1 @@
-import { ToolkitCoordinator, SectionControllerHandle } from '@pie-players/pie-assessment-toolkit';
-export type { SectionControllerContext, SectionControllerEvent, SectionControllerEventType, SectionControllerHandle, SectionControllerKey, SectionControllerLoadedRenderable, SectionSessionPersistenceConfig, SectionSessionPersistenceStrategy, SectionControllerRuntimeState, SectionControllerSessionState, } from '@pie-players/pie-assessment-toolkit';
-export type CoordinatorWithSectionControllers = ToolkitCoordinator & {
-    getOrCreateSectionController(args: {
-        sectionId: string;
-        attemptId?: string;
-        input?: unknown;
-        updateExisting?: boolean;
-        createDefaultController: () => SectionControllerHandle | Promise<SectionControllerHandle>;
-    }): Promise<SectionControllerHandle>;
-    disposeSectionController(args: {
-        sectionId: string;
-        attemptId?: string;
-        persistBeforeDispose?: boolean;
-        clearPersistence?: boolean;
-    }): Promise<void>;
-};
+export type { SectionControllerHandle, SectionSessionPersistenceConfig, SectionControllerRuntimeState, SectionControllerSessionState, } from '@pie-players/pie-assessment-toolkit';

package/dist/controllers/types.d.ts

@@ -1,6 +1,6 @@
 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 { ItemSessionUpdateIntent, SessionCommitReason, AssessmentItemRef, AssessmentSection, ItemEntity, PassageEntity, RubricBlock } from '@pie-players/pie-players-shared';
+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,15 +121,11 @@ export interface SectionCanonicalItemViewModel {
     index: number;
     isCurrent: boolean;
     session: unknown;
-}
-export interface SectionCanonicalSectionViewModel {
-    sectionId: string;
-    currentItemIndex: number;
-    items: SectionCanonicalItemViewModel[];
-}
-export interface SectionCanonicalSessionViewModel {
-    currentItemIndex: number;
-    itemSessionsByCanonicalId: Record<string, 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;
@@ -160,6 +158,8 @@ export interface SessionChangedResult {
         intent?: ItemSessionUpdateIntent;
         complete?: boolean;
         component?: string;
+        elementId?: string;
+        sessionCommitReason?: SessionCommitReason;
         timestamp: number;
     };
 }
@@ -197,15 +197,29 @@ export interface ItemSessionDataChangedEvent extends ItemScopedControllerEventBa
     canonicalItemId: string;
     session: unknown;
     intent?: ItemSessionUpdateIntent;
+    /** The reported completion: the element's own when `elementId` is set. */
     complete?: boolean;
     component?: string;
+    /** The id of the element that reported, when the change names one. */
+    elementId?: string;
+    /** The controller input's `sectionId`. */
+    sectionId?: string;
+    /** Set when the change is a commit at a teardown, navigation or page-hidden seam. */
+    sessionCommitReason?: SessionCommitReason;
 }
 export interface ItemSessionMetaChangedEvent extends ItemScopedControllerEventBase {
     type: "item-session-meta-changed";
     itemId: string;
     canonicalItemId: string;
+    /** The reported completion: the element's own when `elementId` is set. */
     complete?: boolean;
     component?: string;
+    /** The id of the element that reported, when the change names one. */
+    elementId?: string;
+    /** The controller input's `sectionId`. */
+    sectionId?: string;
+    /** Set when the change is a commit at a teardown, navigation or page-hidden seam. */
+    sessionCommitReason?: SessionCommitReason;
 }
 export interface ItemSelectedEvent extends ItemScopedControllerEventBase {
     type: "item-selected";

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';