@rokt/dcui-orchestrator 1.2.1-rc.5 → 1.2.1-rc.50

package/dist/libraries/layout-renderer-utils/src/reducers/breakpoint/coerce-breakpoints.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A layout's breakpoint widths end up in CSS text: the saga builds a matchMedia
+ * query from each one, and the style mapper writes each into a media query or
+ * a class name. Only a finite, non-negative number is a width there. Any other
+ * value becomes INVALID_BREAKPOINT_WIDTH, which the saga and the style mapper
+ * skip, so its styles never apply, as the browser dropped the malformed rule
+ * before. A key is never dropped: the style mapper pairs an element's style
+ * blocks with the breakpoints by position, so a missing key would move every
+ * later block onto the wrong width.
+ */
+/**
+ * Not a width. No media query is registered for it, no style rule is written
+ * for it, and every comparison with it is false, so a breakpoint that carries
+ * it is never active and never styles anything.
+ */
+export declare const INVALID_BREAKPOINT_WIDTH: number;
+export declare function isBreakpointWidth(value: unknown): value is number;
+export declare function coerceBreakpointWidth(value: unknown): number;
+export declare function coerceBreakpoints(breakpoints: unknown): Record<string, number>;

package/dist/libraries/layout-renderer-utils/src/reducers/breakpoint/index.d.ts

@@ -1 +1,2 @@
 export * from './reducer';
+export * from './coerce-breakpoints';

package/dist/libraries/layout-renderer-utils/src/sagas/error/error-codes.d.ts

@@ -1,6 +1,8 @@
 export declare const INVALID_RESPONSE_OBJECT = "INVALID_RESPONSE_OBJECT";
 export declare const INVALID_MODULE_NAME = "INVALID_MODULE_NAME";
 export declare const FAILED_TO_OPEN_LINK = "FAILED_TO_OPEN_LINK";
+export declare const REFUSED_LINK_SCHEME = "REFUSED_LINK_SCHEME";
+export declare const LINK_OPEN_RESULT = "LINK_OPEN_RESULT";
 export declare const FAILED_TO_ISSUE_SIGNAL = "FAILED_TO_ISSUE_SIGNAL";
 export declare const FAILED_TO_CLOSE_PLUGIN = "FAILED_TO_CLOSE_PLUGIN";
 export declare const NO_PARENT_GUID = "NO_PARENT_GUID";
@@ -17,3 +19,4 @@ export declare const FAILED_TO_ESTABLISH_PARTNER_VALIDATION = "FAILED_TO_ESTABLI
 export declare const PARTNER_VALIDATION_UPDATE_FAILED = "PARTNER_VALIDATION_UPDATE_FAILED";
 export declare const CART_SERVICE_RESPONSE_ERROR = "CART_SERVICE_RESPONSE_ERROR";
 export declare const UNSUPPORTED_LAYOUT_ACTION = "UNSUPPORTED_LAYOUT_ACTION";
+export declare const INVALID_GROUP_SIZE = "INVALID_GROUP_SIZE";

package/dist/libraries/layout-renderer-utils/src/sagas/plugin/display.d.ts

@@ -19,6 +19,7 @@ export declare function getDisplaySettings(preset?: LayoutDisplayPreset | null,
         width: string;
     };
     css?: undefined;
+    lockHostScroll?: undefined;
 } | {
     autoresize: boolean;
     css: {
@@ -34,9 +35,11 @@ export declare function getDisplaySettings(preset?: LayoutDisplayPreset | null,
     replaceTargetElement?: undefined;
     outerCss?: undefined;
     innerCss?: undefined;
+    lockHostScroll?: undefined;
 } | {
     autoresize: boolean;
     applyHighestZIndex: boolean;
+    lockHostScroll: boolean;
     replaceTargetElement: string;
     css: {
         zIndex?: number | undefined;

package/dist/libraries/layout-renderer-utils/src/sagas/plugin/sagas.d.ts

@@ -1,10 +1,13 @@
 import { CallEffect, PutEffect, SelectEffect } from '@redux-saga/core/effects';
+import { OutboundPartnerEvent } from '../../../../domain/src/models';
+import { SendPartner } from '../../../../domain/src/behaviors';
 import { FrameControls, LayoutDisplayPreset } from '@rokt/dcui-layout-schema';
 import { RaceEffect } from 'redux-saga/effects';
-import { ContextService, DisplayService, PluginService } from '../../../../plugin-utils/src/index';
+import { ContextService, DisplayService, PartnerInteractionService, PluginService } from '../../../../plugin-utils/src/index';
 import { HandleConfigAction, ReportError } from '../../actions';
 import { EventChannel } from 'redux-saga';
 export declare function closePlugin(contextService: ContextService): Generator<RaceEffect<CallEffect | Generator<SelectEffect | CallEffect, void, boolean>> | SelectEffect | CallEffect | Generator<SelectEffect | CallEffect, void, boolean> | PutEffect<ReportError>, void, boolean>;
+export declare function handlePartnerSend(partnerInteractionService: PartnerInteractionService, { payload }: SendPartner<OutboundPartnerEvent>): Generator<Promise<void>, void, void>;
 export declare function listenToWsdkChannel<LayoutModelType, PluginModelType>(pluginService: PluginService<LayoutModelType>, transformRawConfig: (config: LayoutModelType) => PluginModelType | undefined): Generator<PutEffect<ReportError> | CallEffect<EventChannel<import("../../../../orchestrator/src/actions").SetAttributesAction | import("../../../../orchestrator/src/actions").SetFontsAction | HandleConfigAction<PluginModelType>>> | import("redux-saga/effects").ChannelTakeEffect<HandleConfigAction<PluginModelType>> | PutEffect<HandleConfigAction<PluginModelType>>, void, EventChannel<HandleConfigAction<PluginModelType>> & HandleConfigAction<PluginModelType>>;
 export declare function wsdkSagas<LayoutModelType, PluginModelType>(pluginService: PluginService<LayoutModelType>, transformRawConfig: (config: LayoutModelType) => PluginModelType | undefined): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").ForkEffect<void>>, void, unknown>;
 export declare function displayPlugin(displayService: DisplayService, preset?: LayoutDisplayPreset | null, controls?: FrameControls | null): Generator<CallEffect<void> | import("redux-saga/effects").ForkEffect<void> | PutEffect<{

package/dist/libraries/layout-renderer-utils/src/sagas/utils/index.d.ts

@@ -1,3 +1,4 @@
+import * as linkUtils from './links';
 import * as windowUtils from './window';
 export * from './links';
 export * from './errors';
@@ -5,12 +6,18 @@ export * from './window';
 declare const _default: {
     isWindow(value: unknown): value is windowUtils.WindowRef;
     makePluginWarningAction(err: unknown, message: string, originErrorCode: string, additionalInfo?: Record<string, unknown>): import("../../../../orchestrator/src/actions").ReportError;
+    isHandleUnavailable(value: unknown): value is linkUtils.HandleUnavailable;
     openLink({ url, urlBehavior, external }: {
         url: string;
         urlBehavior: import("../../../../domain/src/models").PluginUrlBehavior;
         external: {
             partner: import("../../../../../index").PartnerInteractionService;
         };
-    }, injectedWindow?: Pick<Window, "top" | "open" | "RoktWebViewSDK">): Promise<windowUtils.WindowRef | null>;
+    }, injectedWindow?: Pick<Window, "top" | "open" | "RoktWebViewSDK"> & {
+        location?: Pick<Location, "href">;
+        navigator?: Omit<Navigator, "userActivation"> & {
+            userActivation?: UserActivation;
+        };
+    }): Promise<windowUtils.WindowRef | linkUtils.HandleUnavailable | null>;
 };
 export default _default;

package/dist/libraries/layout-renderer-utils/src/sagas/utils/links.d.ts

@@ -1,6 +1,33 @@
 import { PluginUrlBehavior } from '../../../../domain/src/models';
 import { PartnerInteractionService } from '../../../../plugin-utils/src/index';
 import { WindowRef } from './window';
+/**
+ * Neither window.open nor the webview bridge distinguishes "blocked" from
+ * "opened, handle withheld" by its return value alone: a blocked popup and an
+ * Android WebView with multiple windows disabled both yield nothing, and the
+ * latter loads the URL in place. So record which path produced the miss and what
+ * the user-activation state was going in, and let the consumer draw conclusions.
+ *
+ * userActivation is Chromium-only, so both flags are null on WebKit and Gecko —
+ * including every iOS webview. isActive false means no transient activation was
+ * left to spend; true does NOT rule out a block, since a site-level popup
+ * permission or an extension can refuse a gesture-initiated open.
+ */
+export type HandleUnavailable = {
+    handleUnavailable: {
+        source: 'window' | 'webview' | null;
+        target: string | null;
+        userActivationActive: boolean | null;
+        userActivationHasBeenActive: boolean | null;
+    };
+};
+export declare function isHandleUnavailable(value: unknown): value is HandleUnavailable;
+type InjectedWindow = Pick<Window, 'top' | 'open' | 'RoktWebViewSDK'> & {
+    location?: Pick<Location, 'href'>;
+    navigator?: Omit<Navigator, 'userActivation'> & {
+        userActivation?: UserActivation;
+    };
+};
 type LinkParams = {
     url: string;
     urlBehavior: PluginUrlBehavior;
@@ -8,5 +35,5 @@ type LinkParams = {
         partner: PartnerInteractionService;
     };
 };
-export declare function openLink({ url, urlBehavior, external }: LinkParams, injectedWindow?: Pick<Window, 'top' | 'open' | 'RoktWebViewSDK'>): Promise<WindowRef | null>;
+export declare function openLink({ url, urlBehavior, external }: LinkParams, injectedWindow?: InjectedWindow): Promise<WindowRef | HandleUnavailable | null>;
 export {};

package/dist/libraries/module-connector/src/main.d.ts

@@ -1,6 +1,6 @@
 export { ModuleAttributes } from './models/module-attributes';
 export { ModuleConnectorBuilder, AppSettings, } from './models/module-connector-builder';
-export { IGateway, IDisposable, Gateway, GetFonts, GatewayFactory, ActionInterceptor, EmptyGateway, GlobalGateway, GlobalGatewayFactory, makeGatewayFactory, ModuleEventListener, } from './models/gateway';
+export { IGateway, ContinuousGatewayService, IDisposable, Gateway, GetFonts, GatewayFactory, ActionInterceptor, EmptyGateway, GlobalGateway, GlobalGatewayFactory, makeGatewayFactory, ModuleEventListener, } from './models/gateway';
 export * from './models/module';
 export { AbstractStore } from './models/abstract-store';
 export { AbstractGlobalStore, GlobalStoreOfferContext, } from './models/abstract-global-store';

package/dist/libraries/module-connector/src/models/gateway.d.ts

@@ -1,4 +1,4 @@
-import { GlobalState, Interactivity } from '../../../domain/src/models';
+import { GlobalState, Interactivity, PluginLayoutChild } from '../../../domain/src/models';
 import { GlobalActions } from '../../../domain/src/behaviors';
 import { ChildPluginFactoryInterface, Fonts, PartnerInteractionInterface } from '@rokt/plugin';
 import { Subscriber } from '@rokt/plugin/interface/subscriber';
@@ -10,6 +10,11 @@ export type ChildPluginFactoryOptions = Parameters<ChildPluginFactory>[0];
 export type GetFonts = () => Fonts;
 export type GatewayFactory<State extends object, Action extends object> = (offerContext: GlobalStoreOfferContext, interactivityChannel: ISubscribable<Interactivity> & IClearable) => IGateway<State, Action> & IDisposable;
 export type ActionInterceptor<Action extends object> = (action: Action) => Action | undefined;
+/** Trusted parent services; the gateway binds the module's served offer identity. */
+export interface ContinuousGatewayService {
+    register(context: GlobalStoreOfferContext, dispatch: (action: GlobalActions) => void): () => void;
+    launch(context: GlobalStoreOfferContext, child: PluginLayoutChild): Promise<boolean>;
+}
 export type ModuleEventListener = {
     name: string;
     source: 'partner' | '*';
@@ -21,14 +26,20 @@ export interface IGateway<State extends object, Action extends object> {
     onInteractivityChange(callback: (interactivity: Interactivity) => void): () => void;
     globalDispatch(action: Action): void;
     createChildPlugin: ChildPluginFactory;
+    registerContinuousResponseHandler?: (dispatch: (action: GlobalActions) => void) => () => void;
+    launchContinuousChild?: (child: PluginLayoutChild) => Promise<boolean>;
+    scrollHostToViewportOffset?: (viewportOffsetY: number) => Promise<void>;
 }
 export interface IDisposable {
     dispose(): void;
 }
-export declare function makeGatewayFactory<State extends object, Action extends object>(globalStore: AbstractGlobalStore<State, Action>, createChildPlugin: ChildPluginFactory, onPartnerEvent: PartnerEventReceiver, getFonts?: GetFonts): GatewayFactory<State, Action>;
+export declare function makeGatewayFactory<State extends object, Action extends object>(globalStore: AbstractGlobalStore<State, Action>, createChildPlugin: ChildPluginFactory, onPartnerEvent: PartnerEventReceiver, getFonts?: GetFonts, scrollHostToViewportOffset?: (viewportOffsetY: number) => Promise<void>, continuous?: ContinuousGatewayService): GatewayFactory<State, Action>;
 export declare class Gateway<State extends object, Action extends object> implements IGateway<State, Action>, IDisposable {
     #private;
-    constructor(store: AbstractGlobalStore<State, Action>, createChildPlugin: ChildPluginFactory, context: GlobalStoreOfferContext, interactivityChannel: ISubscribable<Interactivity> & IClearable, onPartnerEvent: PartnerEventReceiver, getFonts?: GetFonts);
+    scrollHostToViewportOffset?: (viewportOffsetY: number) => Promise<void>;
+    registerContinuousResponseHandler?: (dispatch: (action: GlobalActions) => void) => () => void;
+    launchContinuousChild?: (child: PluginLayoutChild) => Promise<boolean>;
+    constructor(store: AbstractGlobalStore<State, Action>, createChildPlugin: ChildPluginFactory, context: GlobalStoreOfferContext, interactivityChannel: ISubscribable<Interactivity> & IClearable, onPartnerEvent: PartnerEventReceiver, getFonts?: GetFonts, scrollHostToViewportOffset?: (viewportOffsetY: number) => Promise<void>, continuous?: ContinuousGatewayService);
     onGlobalStateChange(callback: (globalState: State) => void): () => void;
     onInteractivityChange(callback: (interactivity: Interactivity) => void): () => void;
     onEvent(...moduleEventListeners: Array<ModuleEventListener>): () => void;

package/dist/libraries/module-connector/src/models/module-attributes.d.ts

@@ -7,6 +7,9 @@ export interface ModuleAttributes {
     childLayouts: string;
     schemaVersion: string;
     visible: 'true' | 'false';
+    'continuous-measurement'?: string;
+    'expanded-owns-viewability'?: string;
+    'measurement-occluded'?: string;
     container: 'row' | 'column';
     interactivity: Interactivity;
     offerState: string;

package/dist/libraries/module-connector/src/models/module-connector-builder.d.ts

@@ -19,6 +19,7 @@ export interface IModuleConnector extends HTMLElement {
     getOfferPositionAttr(): number;
     getJSONAttr<Result>(att: string, defaultValue?: string): Result;
     connectedCallback(): void;
+    disconnectedCallback(): void;
 }
 export declare class ModuleConnectorBuilder {
     logger: (log: Log) => void;

package/dist/libraries/module-utils/src/sagas/child-layouts/sagas.d.ts

@@ -13,5 +13,7 @@ type BridgeChannelMessage = {
 export declare function childLayoutBridge(gateway: GlobalGateway, logger: (log: Log) => void, childPlugin: ChildPluginInterface<BasicObject>, offerContext: {
     offer: PluginOffer;
     offerPositionIndex: number | undefined;
+    childInstanceGuid: string;
+    advanceOnDismiss?: boolean;
 }): Generator<PutEffect | CallEffect | CancelledEffect | RaceEffect<ChannelTakeEffect<BridgeChannelMessage> | CallEffect>, void, never>;
 export {};

package/dist/libraries/orchestrator/src/components/progress-control/progress-control.d.ts

@@ -1,47 +1,4 @@
 import React from 'react';
-import { ProgressControlModel, NonInteractableChildren, WhenPredicate } from '@rokt/dcui-layout-schema';
-export interface ProgressControlProps {
-    /**
-     *  - `a11yLabel`: the aria-label for the button
-     *  - `direction`: 'Forward' | 'Backward'.
-     *  - `children`: it can accept below nodes,
-     *    * `Row`
-     *    * `Column`
-     *    * `ZStack`
-     *    * `BasicText`
-     *    * `StaticImage`
-     *    * `When`
-     *    * `InlineContainer`
-     *  - `styles`:
-     *    * `elements`:
-     *      * `own`:
-     *        - `container`
-     *        - `background`
-     *        - `border`
-     *        - `dimension`
-     *        - `flexChild`
-     *        - `spacing`
-     *    * `transitions`:
-     *      - `type`: 'Conditional'
-     *      - `transition`:
-     *        * `predicates`: WhenPredicate[]
-     *        * `duration`: number
-     *        * `value`:
-     *          * `own`:
-     *            - `container`
-     *            - `background`
-     *            - `border`
-     *            - `dimension`
-     *            - `flexChild`
-     *            - `spacing`
-     */
-    schema: ProgressControlModel<NonInteractableChildren, WhenPredicate>;
-    testId?: string;
-}
-/**The ProgressControl is a progress node that facilitates navigation
- * through sequential steps or stages of a process or content.<br>
- * It offers users the ability to move both forward and backward
- * within a linear progression, allowing them to review and control their journey.<br>
- * *Where can we use this: __outer layout__*
- * */
+import { ProgressControlProps as SharedProgressControlProps } from '../../../../dcui-components/src/index';
+export type ProgressControlProps = Omit<SharedProgressControlProps, 'onClick' | 'disabled'>;
 export declare function ProgressControl(props: ProgressControlProps): React.JSX.Element;

package/dist/libraries/orchestrator/src/components/progress-indicator/progress-indicator.d.ts

@@ -1,9 +1 @@
-import * as React from 'react';
-import { ProgressIndicatorProps } from './types';
-/** The ProgressIndicator is a progress node that provides users with real-time
- * feedback on the status of ongoing processes or actions.<br>
- * It's a visual representation of progress, often displayed as a bar,
- * circle, or numerical percentage.<br>
- * *Where can we use this: __outer layout__*
- * */
-export declare function ProgressIndicator({ activeIndex, startIndex, numOfIndicators, schema, }: ProgressIndicatorProps): React.JSX.Element | null;
+export { ProgressIndicator } from '../../../../dcui-components/src/index';

package/dist/libraries/orchestrator/src/components/progress-indicator/types.d.ts

@@ -1,87 +1 @@
-import { ProgressIndicatorModel, WhenPredicate } from '@rokt/dcui-layout-schema';
-export interface StateProps {
-    /** The number of indicators */
-    numOfIndicators: number;
-    /** The currently active index. */
-    activeIndex: number;
-    /** The index of the indicator to start displaying from **/
-    startIndex: number;
-}
-export interface OwnProps {
-    /**
-     *  - `indicator`: The string content of the indicator.
-     *  - `styles`:
-     *    * `elements`:
-     *      * `own`:
-     *        - `container`
-     *        - `background`
-     *        - `border`
-     *        - `dimension`
-     *        - `flexChild`
-     *        - `spacing`
-     *      * `indicator`:
-     *        - `container`
-     *        - `background`
-     *        - `border`
-     *        - `dimension`
-     *        - `flexChild`
-     *        - `spacing`
-     *        - `text`
-     *      * `activeIndicator`:
-     *        - `container`
-     *        - `background`
-     *        - `border`
-     *        - `dimension`
-     *        - `flexChild`
-     *        - `spacing`
-     *        - `text`
-     *      * `seenIndicator`:
-     *        - `container`
-     *        - `background`
-     *        - `border`
-     *        - `dimension`
-     *        - `flexChild`
-     *        - `spacing`
-     *        - `text`
-     *    * `transitions`:
-     *      - `type`: 'Conditional'
-     *      - `transition`:
-     *        * `predicates`: WhenPredicate[]
-     *        * `duration`: number
-     *        * `value`:
-     *          * `own`:
-     *            - `container`
-     *            - `background`
-     *            - `border`
-     *            - `dimension`
-     *            - `flexChild`
-     *            - `spacing`
-     *          * `indicator`:
-     *            - `container`
-     *            - `background`
-     *            - `border`
-     *            - `dimension`
-     *            - `flexChild`
-     *            - `spacing`
-     *            - `text`
-     *          * `activeIndicator`:
-     *            - `container`
-     *            - `background`
-     *            - `border`
-     *            - `dimension`
-     *            - `flexChild`
-     *            - `spacing`
-     *            - `text`
-     *          * `seenIndicator`:
-     *            - `container`
-     *            - `background`
-     *            - `border`
-     *            - `dimension`
-     *            - `flexChild`
-     *            - `spacing`
-     *            - `text`
-     */
-    schema: ProgressIndicatorModel<WhenPredicate>;
-}
-export interface ProgressIndicatorProps extends OwnProps, StateProps {
-}
+export type { ProgressIndicatorProps, ProgressIndicatorStateProps as StateProps, ProgressIndicatorSchemaProps as OwnProps, } from '../../../../dcui-components/src/index';

package/dist/libraries/orchestrator/src/measurement/creative-measurement.d.ts

@@ -0,0 +1,54 @@
+import { RaiseSignal } from '../../../domain/src/behaviors';
+import { Impression, Viewed } from '../../../domain/src/models';
+export interface CreativeIdentity {
+    creativeInstanceGuid: string;
+    offerPositionIndex: number;
+}
+export interface PresentationIdentity extends CreativeIdentity {
+    sessionId: string;
+    revision: number;
+}
+export type Qualification = Pick<Viewed, 'supportedByBrowser' | 'inferred'>;
+type MeasurementStore = {
+    dispatch(action: RaiseSignal): void;
+};
+/** One registry per parent store/selection, never one per child session. */
+export declare function getContinuousMeasurement(store: MeasurementStore): CreativeMeasurement;
+/**
+ * Parent-owned creative signals. Layout/slot signals deliberately bypass this
+ * ledger. Registration is explicit: the disabled capability and ordinary layouts
+ * must never change their existing measurement just because a child exists.
+ */
+export declare class CreativeMeasurement {
+    private readonly emit;
+    private readonly creatives;
+    private readonly presentations;
+    private sessionId;
+    private highestRevision;
+    private occluded;
+    private readonly listeners;
+    constructor(emit: (action: RaiseSignal) => void);
+    /** A new served selection is a new lifetime; reopening the child is not. */
+    resetSelection(): void;
+    registerCreative(identity: CreativeIdentity, ownsViewability: boolean): void;
+    getEmbeddedPolicy(identity: CreativeIdentity): {
+        registered: boolean;
+        ownsViewability: boolean;
+        occluded: boolean;
+    };
+    subscribe(listener: () => void): () => void;
+    setOccluded(occluded: boolean): void;
+    /** Consumes only opted-in CREATIVE signals; false means use the legacy path. */
+    reportEmbedded(identity: CreativeIdentity, signal: Impression | Viewed): boolean;
+    /** Called after the child applied the snapshot, not when it was configured. */
+    acknowledge(identity: PresentationIdentity): boolean;
+    beginSession(sessionId: string): void;
+    endSession(): void;
+    reportExpanded(identity: PresentationIdentity, qualification?: Qualification): boolean;
+    private getCreative;
+    private matchesAcknowledged;
+    private render;
+    private qualify;
+    private notify;
+}
+export {};

package/dist/libraries/orchestrator/src/reducers/progression/reducer.d.ts

@@ -1,5 +1,13 @@
 import { AnyAction } from '@reduxjs/toolkit';
 import { ProgressionState } from '../../models';
 export declare function makeInitialProgressionState(): null;
+/**
+ * A group size is usable only as a whole number from 1 up to the total count.
+ * The value comes from the layout's viewableItems, which the plugin does not
+ * re-check at runtime: a fraction below 1 makes totalCount / groupSize as
+ * large as the layout likes, and a fraction above 1 produces fractional offer
+ * indexes.
+ */
+export declare function isValidGroupSize(groupSize: number, totalCount: number): boolean;
 export declare function getNumberOfGroups(totalCount: number, groupSize: number): number;
 export declare function progressionReducer(state: ProgressionState | undefined, action: AnyAction): ProgressionState;

package/dist/libraries/orchestrator/src/sagas/child-layouts/continuous-child-host.d.ts

@@ -0,0 +1,15 @@
+import { ContinuousPresentationInput } from '../../../../domain/src/behaviors';
+import { ContinuousGatewayService } from '../../../../module-connector/src/main';
+import type { AppStore } from '../../store';
+import { PluginService } from '../../plugin-service';
+import { ContinuousChildCoordinator } from './continuous-child';
+export declare function isContinuousEngagement(action: unknown): boolean;
+/** Connect the coordinator to trusted selected slots and the existing module response path. */
+export declare function makeContinuousChildHost(store: Pick<AppStore, 'getState' | 'dispatch' | 'subscribe'>, service: PluginService, enabled?: boolean): {
+    gateway: ContinuousGatewayService | undefined;
+    coordinator: ContinuousChildCoordinator;
+    getSequence: (key: string, onRejected?: (reason: string) => void) => ContinuousPresentationInput[] | undefined;
+    transformAction(action: unknown): unknown;
+    observeAction(action: unknown): void;
+    close(): Promise<void>;
+};

package/dist/libraries/orchestrator/src/sagas/child-layouts/continuous-child.d.ts

@@ -0,0 +1,52 @@
+import { LinkOpenTarget } from '@rokt/dcui-layout-schema';
+import { ContinuousExposure, ContinuousPresentation, ContinuousPresentationInput } from '../../../../domain/src/behaviors';
+export interface ContinuousChildTransport {
+    send(name: string, payload: object): Promise<void>;
+    onEvent(name: string): {
+        subscribe(callback: (value: unknown) => void): {
+            unsubscribe(): void;
+        };
+    };
+    close(): Promise<void>;
+    onClose(): Promise<void>;
+}
+export interface ContinuousChildDependencies {
+    createChild(presentation: ContinuousPresentation): Promise<ContinuousChildTransport>;
+    getSequence(key: string): ContinuousPresentationInput[] | undefined;
+    getActivePosition(): number;
+    navigate(position: number): void;
+    respond(position: number, key: 'positive' | 'negative', openLinks?: LinkOpenTarget): Promise<void>;
+    dismiss(position: number, dismissalMethod?: string): Promise<void>;
+    onApplied?(presentation: ContinuousPresentation): void;
+    onExposure?(presentation: ContinuousPresentation, report: ContinuousExposure): void;
+    onOcclusion?(occluded: boolean): void;
+    onError?(error: Error): void;
+}
+export declare function compatibleContinuousSequence(sequence: ContinuousPresentationInput[]): boolean;
+/** One parent-owned session. Never rebinds the launching module's gateway. */
+export declare class ContinuousChildCoordinator {
+    private readonly dependencies;
+    private child?;
+    private sequence;
+    private current?;
+    private applied?;
+    private acknowledged;
+    private subscriptions;
+    private actionIds;
+    private busy;
+    private opening;
+    private ready;
+    private epoch;
+    private acknowledgementTimer?;
+    private key;
+    constructor(dependencies: ContinuousChildDependencies);
+    open(position: number, key: string): Promise<boolean>;
+    /** Called on authoritative parent progression changes. */
+    sync(): void;
+    private makePresentation;
+    private push;
+    private request;
+    private awaitAcknowledgement;
+    private reset;
+    close(): Promise<void>;
+}

package/dist/libraries/orchestrator/src/sagas/index.d.ts

@@ -1,4 +1,4 @@
 import { GlobalGatewayFactory } from '../../../module-connector/src/main';
 import { PluginService } from '../plugin-service';
 export * from './plugin';
-export declare function appSagas(pluginService: PluginService, gatewayFactory: GlobalGatewayFactory): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").ForkEffect<void> | Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").TakeEffect, void, import("redux-saga").TakeableChannel<unknown> | undefined> | Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").ActionChannelEffect | import("redux-saga/effects").ChannelTakeEffect<unknown>, void, import("redux-saga").TakeableChannel<unknown> | undefined>>, void, unknown>;
+export declare function appSagas(pluginService: PluginService, gatewayFactory: GlobalGatewayFactory, closeContinuous?: () => Promise<void>): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").ForkEffect<void> | Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").TakeEffect, void, import("redux-saga").TakeableChannel<unknown> | undefined> | Generator<import("redux-saga/effects").CallEffect | import("redux-saga/effects").ActionChannelEffect | import("redux-saga/effects").ChannelTakeEffect<unknown>, void, import("redux-saga").TakeableChannel<unknown> | undefined>>, void, unknown>;

package/dist/libraries/orchestrator/src/sagas/offer-engagement/sagas.d.ts

@@ -3,9 +3,9 @@ import { PluginCreativeResponseOption } from '../../../../domain/src/models';
 import { CallEffect, PutEffect, SelectEffect, TakeEffect } from 'redux-saga/effects';
 import { ReportError, ClosePlugin, OfferEngagement } from '../../actions';
 import { ContextService, PartnerInteractionService } from '../../../../plugin-utils/src/index';
-import { WindowRef } from '../../../../layout-renderer-utils/src/index';
-type NextValues = WindowRef | CallEffect | null | undefined;
-type OfferCompletionResult = 'SUCCESS' | 'UNSPECIFIED' | 'ERROR' | 'EXPLICIT_DISMISSAL' | 'IMPLICIT_DISMISSAL' | 'END';
+import { HandleUnavailable, WindowRef } from '../../../../layout-renderer-utils/src/index';
+type NextValues = WindowRef | HandleUnavailable | CallEffect | null | undefined;
+type OfferCompletionResult = 'SUCCESS' | 'ERROR' | 'EXPLICIT_DISMISSAL' | 'IMPLICIT_DISMISSAL' | 'END';
 declare const handleUrlResponse: (args_0: PluginCreativeResponseOption, args_1: ContextService, args_2: import("@rokt/plugin").SenderReceiver, args_3: OfferEngagement) => Generator<TakeEffect | NextValues | PutEffect<RaiseSignal | ClosePlugin | ReportError>, OfferCompletionResult, NextValues>;
 export declare function processOfferResponse(dependencies: {
     context: ContextService;

package/dist/libraries/orchestrator/src/sagas/progression/sagas.d.ts

@@ -1,11 +1,17 @@
 import { CallEffect, PutEffect, SelectEffect, TakeEffect } from 'redux-saga/effects';
-import { ProcessProgression, StateActions, UpdateActiveBreakpointAction } from '../../actions';
+import { InitialiseBreakpointAction, ProcessProgression, StateActions, UpdateActiveBreakpointAction } from '../../actions';
 import { CloseOnNegativeResponsePolicy } from '@rokt/dcui-layout-schema';
 type ProgressResult = {
     exists: boolean;
     isLastOffer: boolean;
 };
 type NextValues = ProgressResult | boolean | number | CloseOnNegativeResponsePolicy | undefined;
-export declare function updateGroupSize(action: UpdateActiveBreakpointAction): Generator<SelectEffect | PutEffect<StateActions>, void, Array<number> | undefined>;
+/**
+ * Sends the group size for the breakpoint the action names, on the first
+ * breakpoint read (INITIALISE_BREAKPOINT) and on every later change
+ * (UPDATE_ACTIVE_BREAKPOINT). The first read names no breakpoint when the
+ * channel reports none, and the reducer reads that as the default one.
+ */
+export declare function updateGroupSize(action: UpdateActiveBreakpointAction | InitialiseBreakpointAction): Generator<SelectEffect | PutEffect<StateActions>, void, Array<number> | undefined>;
 export declare function processProgress(action: ProcessProgression): Generator<SelectEffect | CallEffect | PutEffect | TakeEffect, void, NextValues>;
 export {};

package/dist/libraries/orchestrator/src/sagas/utils/distribution.d.ts

@@ -14,3 +14,24 @@ export type Distribution = {
 };
 export declare function getDistribution(layout: LayoutSchemaModel): Distribution | undefined;
 export declare function getDistributionViewableItems(distribution: Distribution | undefined): Array<number> | undefined;
+/**
+ * The layout's viewableItems entry for a breakpoint, made safe for the
+ * progression reducer: a value of at least 1 is rounded down to a whole
+ * number, so 2.5 keeps a group of 2, and anything else (a value below 1,
+ * a missing entry, a value that is not a finite number) becomes 1, the
+ * value the reducer already uses when a layout names no group size.
+ */
+export declare function normaliseGroupSize(value: number | undefined): number;
+/**
+ * True when normaliseGroupSize uses a value other than the one the layout
+ * configured, the case the plugin saga reports as INVALID_GROUP_SIZE. A
+ * missing entry is a layout that names no group size, not a changed one.
+ */
+export declare function isGroupSizeChanged(value: number | undefined): boolean;
+/**
+ * A normalised group size capped at the number of offers the placement
+ * holds: the reducer refuses a group larger than the placement, so one offer
+ * with viewableItems [2] at a breakpoint keeps a group of 1 instead of a
+ * null progression.
+ */
+export declare function capGroupSize(groupSize: number, slotSize: number): number;

package/dist/libraries/orchestrator/src/sagas/utils/index.d.ts

@@ -3,5 +3,8 @@ export { Distribution } from './distribution';
 declare const _default: {
     getDistribution(layout: import("@rokt/dcui-layout-schema").LayoutSchemaModel): distributionUtils.Distribution | undefined;
     getDistributionViewableItems(distribution: distributionUtils.Distribution | undefined): Array<number> | undefined;
+    normaliseGroupSize(value: number | undefined): number;
+    isGroupSizeChanged(value: number | undefined): boolean;
+    capGroupSize(groupSize: number, slotSize: number): number;
 };
 export default _default;

package/dist/libraries/plugin-utils/src/plugin-service/display.d.ts

@@ -1,6 +1,7 @@
 import { DisplayInterface, PluginInterface } from '@rokt/plugin';
 import { EventChannel } from 'redux-saga';
 export type DisplayService = Pick<DisplayInterface, 'setDisplaySettings'> & {
+    scrollHostToViewportOffset?(viewportOffsetY: number): Promise<void>;
     activeBreakpointEventChannel?(breakpoints: Record<string, number>): EventChannel<string>;
 };
 export declare const makeDisplayService: (pluginInterface: Pick<PluginInterface, 'display'>) => DisplayService;

package/dist/modules/add-to-cart/src/components/when-catalog-quantity/when-catalog-quantity.d.ts

@@ -3,7 +3,8 @@ import { LayoutSchemaModel, EqualityWhenCondition, OrderableWhenCondition } from
 export type QuantityCondition = EqualityWhenCondition | OrderableWhenCondition;
 export interface QuantityPredicate {
     condition: QuantityCondition;
-    value: number;
+    /** Fixed number or a numeric string resolved through the current data mapper. */
+    value: number | string;
 }
 export interface WhenCatalogQuantityModel {
     cartItemId: string;

package/dist/modules/instant-purchase/src/actions/instant-purchase.d.ts

@@ -42,6 +42,8 @@ export interface PushTaxAndShippingPayload {
 }
 export interface MarkTaxAndShippingPendingPayload {
     cacheKey: string;
+    requestId: string;
+    preserveEstimate?: boolean;
 }
 export declare const INITIATE_INSTANT_PURCHASE = "INSTANT_PURCHASE/INITIATE";
 export type InitiateInstantPurchase = {
@@ -92,6 +94,8 @@ export type SetActiveTaxAndShippingKey = {
 };
 export type InitiateTaxAndShippingPayload = {
     catalogItem: PluginCatalogItem;
+    force?: boolean;
+    requestId?: string;
 };
 export declare const INITIATE_TAX_AND_SHIPPING = "INSTANT_PURCHASE/INITIATE_TAX_AND_SHIPPING";
 export type InitiateTaxAndShipping = {