@rokt/dcui-orchestrator 1.2.1-rc.3 → 1.2.1-rc.31

package/dist/libraries/layout-renderer-utils/src/reducers/attributes/reducer.d.ts

@@ -0,0 +1,4 @@
+import { AnyAction } from '@reduxjs/toolkit';
+import { AttributesState } from '../../models';
+export declare function makeInitialAttributesState(): AttributesState;
+export declare function attributesReducer(state: AttributesState | undefined, action: AnyAction): AttributesState;

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

@@ -2,6 +2,7 @@ import { CoreAppState } from '../models';
 import { breakpointReducer } from './breakpoint';
 import { layoutReducer } from './layout';
 import { activeReducer } from './active';
+import { attributesReducer } from './attributes';
 import { fontsReducer } from './fonts';
 import { signalReducer } from './signal';
 import { serializableCacheReducer } from './serializable-cache';
@@ -12,6 +13,7 @@ import { formStatesReducer } from './form-states';
 export * from './breakpoint';
 export * from './layout';
 export * from './active';
+export * from './attributes';
 export * from './fonts';
 export * from './signal';
 export * from './serializable-cache';
@@ -23,6 +25,7 @@ export declare const coreAppReducers: {
     layout: typeof layoutReducer;
     breakpoint: typeof breakpointReducer;
     active: typeof activeReducer;
+    attributes: typeof attributesReducer;
     fonts: typeof fontsReducer;
     signal: typeof signalReducer;
     serializableCache: typeof serializableCacheReducer;

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

@@ -1,5 +1,5 @@
 import { EventChannel } from 'redux-saga';
 import { ThemeInterface } from '@rokt/plugin';
-import { ConfigService } from '../../../../plugin-utils/src/index';
-import { HandleConfigAction, SetFontsAction } from '../../actions';
-export declare function makeWsdkChannel<LayoutModelType, PluginModelType>(configService: ConfigService<LayoutModelType>, themeService: ThemeInterface, transformRawConfig: (config: LayoutModelType) => PluginModelType | undefined): EventChannel<HandleConfigAction<PluginModelType> | SetFontsAction>;
+import { AttributesService, ConfigService } from '../../../../plugin-utils/src/index';
+import { HandleConfigAction, SetAttributesAction, SetFontsAction } from '../../actions';
+export declare function makeWsdkChannel<LayoutModelType, PluginModelType>(configService: ConfigService<LayoutModelType>, themeService: ThemeInterface, transformRawConfig: (config: LayoutModelType) => PluginModelType | undefined, attributesService?: AttributesService): EventChannel<HandleConfigAction<PluginModelType> | SetFontsAction | SetAttributesAction>;

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,11 +1,14 @@
 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 listenToWsdkChannel<LayoutModelType, PluginModelType>(pluginService: PluginService<LayoutModelType>, transformRawConfig: (config: LayoutModelType) => PluginModelType | undefined): Generator<PutEffect<ReportError> | CallEffect<EventChannel<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 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<{
     type: "ACTIVE/ADD";

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/actions/index.d.ts

@@ -36,6 +36,7 @@ export declare const stateActionTypes: {
     readonly INITIALISE_BREAKPOINT: "BREAKPOINT/INITIALISE";
     readonly ACTIVE_ADD: "ACTIVE/ADD";
     readonly ACTIVE_DELETE: "ACTIVE/DELETE";
+    readonly SET_ATTRIBUTES: "ATTRIBUTES/SET";
     readonly SET_FONTS: "FONTS/SET";
     readonly QUEUE_SIGNAL: "SIGNAL/QUEUE";
     readonly SIGNAL_PROCESSED: "SIGNAL/PROCESSED";

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/index.d.ts

@@ -14,6 +14,7 @@ export declare const appReducers: {
     layout: typeof import("../../../layout-renderer-utils/src/index").layoutReducer;
     breakpoint: typeof import("../../../layout-renderer-utils/src/index").breakpointReducer;
     active: typeof import("../../../layout-renderer-utils/src/index").activeReducer;
+    attributes: typeof import("../../../layout-renderer-utils/src/index").attributesReducer;
     fonts: typeof import("../../../layout-renderer-utils/src/index").fontsReducer;
     signal: typeof import("../../../layout-renderer-utils/src/index").signalReducer;
     serializableCache: typeof import("../../../layout-renderer-utils/src/index").serializableCacheReducer;

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/plugin-utils/src/plugin-service/attributes.d.ts

@@ -0,0 +1,7 @@
+import { PluginInterface } from '@rokt/plugin';
+import { NormalizedAttributes } from '@rokt/plugin/interface/attributes';
+import { Callback, Unsubscriber } from '@rokt/plugin/interface/subscriber';
+export type AttributesService = {
+    subscribe(value?: Callback<[NormalizedAttributes]>, error?: Callback, complete?: Callback): Unsubscriber;
+};
+export declare const makeAttributesService: (pluginInterface: Pick<PluginInterface, "attributes">) => AttributesService;

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/libraries/plugin-utils/src/plugin-service/index.d.ts

@@ -1,4 +1,5 @@
 import { ErrorInterface, PluginInterface, RDNInterface, ThemeInterface } from '@rokt/plugin';
+import { AttributesService } from './attributes';
 import { ContextService } from './context';
 import { MetricsService } from './metrics';
 import { DisplayService } from './display';
@@ -6,8 +7,9 @@ import { PartnerInteractionService } from './partner-interaction';
 import { ParentInteractionService } from './parent-interaction';
 import { ConfigService } from './config';
 import { ChildPluginService } from './child-plugin';
-export { ContextService, MetricsService, DisplayService, PartnerInteractionService, ParentInteractionService, ConfigService, ChildPluginService, };
+export { AttributesService, ContextService, MetricsService, DisplayService, PartnerInteractionService, ParentInteractionService, ConfigService, ChildPluginService, };
 export interface PluginService<T> {
+    attributesService: AttributesService;
     contextService: ContextService;
     configService: ConfigService<T>;
     partnerInteractionService: PartnerInteractionService;

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

@@ -6,10 +6,17 @@ export declare const TRIGGER_SELECT_ITEM = "CATALOG/TRIGGER_SELECT_ITEM";
 export type TriggerSelectItemAction = {
     type: typeof TRIGGER_SELECT_ITEM;
     payload: SetSelectedItemPayload;
+    preserveAttributeSelections?: boolean;
 };
 export declare const SET_SELECTED_ITEM = "CATALOG/SET_SELECTED_ITEM";
 export type SetSelectedItemAction = {
     type: typeof SET_SELECTED_ITEM;
     payload: SetSelectedItemPayload;
+    preserveAttributeSelections?: boolean;
 };
-export type CatalogSelectionActions = SetSelectedItemAction | TriggerSelectItemAction;
+export declare const SET_CATALOG_ATTRIBUTE_SELECTIONS = "CATALOG/SET_ATTRIBUTE_SELECTIONS";
+export type SetCatalogAttributeSelectionsAction = {
+    type: typeof SET_CATALOG_ATTRIBUTE_SELECTIONS;
+    payload: Record<string, string>;
+};
+export type CatalogSelectionActions = SetCatalogAttributeSelectionsAction | SetSelectedItemAction | TriggerSelectItemAction;

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 = {

package/dist/modules/instant-purchase/src/components/catalog-device-pay-button/catalog-device-pay-button.d.ts

@@ -112,7 +112,15 @@ export interface CatalogDevicePayButtonProps {
     testId?: string;
 }
 type CatalogDevicePayButtonStyles = NonNullable<CatalogDevicePayButtonProps['schema']['styles']>;
+/**
+ * Whether the backend marked this catalog item as purchasable with PayPal. The
+ * flag rides in the item's `providerData` JSON and is omitted when false, so
+ * anything other than an explicit `true` (absent, malformed, wrong type) means
+ * the item is not PayPal-enabled.
+ */
+export declare function isPayPalEnabled(providerData: string | undefined): boolean;
 export declare function getCatalogDevicePayButtonStyles(styles: CatalogDevicePayButtonProps['schema']['styles']): CatalogDevicePayButtonStyles;
+export declare function getPayPalButtonStyles(styles: CatalogDevicePayButtonProps['schema']['styles']): CatalogDevicePayButtonStyles;
 /**The CatalogDevicePayButton is a button node that generates a Call-to-Action button
  * for initiating a device payment transaction using the associated payment provider.
  * *Where can we use this: __layout variant__*

package/dist/modules/instant-purchase/src/components/catalog-selectors-stacked/catalog-selectors-stacked.d.ts

@@ -1,6 +1,36 @@
 import React from 'react';
 import { CatalogSelectorsStackedModel, LayoutSchemaModel, WhenPredicate } from '@rokt/dcui-layout-schema';
 export interface CatalogSelectorsStackedProps<Template extends LayoutSchemaModel> {
+    /**
+     *  - `default`: the template rendered once per variant dimension.
+     *    `CatalogDropdown` includes its own visible dimension label. Do not add a
+     *    separate label node. Each render also exposes tokens for custom content:
+     *    * `%^DATA.variantAttribute.attributeId^%`: the dimension id, e.g.
+     *      `color`. It comes from the merchant's variant option key and is
+     *      neither normalised nor guaranteed lowercase or single-word, so
+     *      `shoe_size` reaches the shopper verbatim. Apply casing with the node's
+     *      `text.textTransform` rather than transforming the value, so `When`
+     *      comparisons stay stable.
+     *    * `%^DATA.variantAttribute.hasMultipleOptions^%`: `"true"` or `"false"`.
+     *      `CatalogDropdown` renders neither label nor control for a single option,
+     *      and the whole template for that dimension is hidden, so it takes no
+     *      space in the stack.
+     *    Tokens from the enclosing scope stay resolvable alongside these.
+     *
+     *    Keep the dropdown mounted. A `When` that encloses it would stop it mounting, and
+     *    a dropdown that never mounts never registers its validator field key —
+     *    a trigger that then resolves zero keys fails closed, blocking the CTA
+     *    with nothing on screen to explain it.
+     *
+     *    Bind custom text with `BasicText`. `RichText` sends the value through the
+     *    HTML sanitiser, which throws on markup-shaped input; the node is then
+     *    dropped by its error boundary.
+     *  - `dropdown`: accepted by the layout schema, currently ignored — this
+     *    component only ever renders `default`.
+     *  - `styles`:
+     *    * `elements`:
+     *      - `own`
+     */
     schema: CatalogSelectorsStackedModel<Template, WhenPredicate>;
     testId?: string;
 }

package/dist/modules/instant-purchase/src/models/state/device-pay-availability.d.ts

@@ -1,5 +1,6 @@
 export type DevicePayAvailabilityResponse = {
     applePay?: boolean;
     afterpay?: boolean;
+    paypal?: boolean;
 };
 export type DevicePayAvailabilityState = DevicePayAvailabilityResponse | null;

package/dist/modules/instant-purchase/src/models/state/instant-purchase.d.ts

@@ -24,6 +24,8 @@ export interface TaxAndShippingData {
 }
 export interface TaxAndShippingEntry {
     isPending: boolean;
+    requestId?: string;
+    purchaseId?: string;
     taxAndShippingData?: TaxAndShippingData;
 }
 export interface TaxAndShippingState {
@@ -34,6 +36,7 @@ export declare const INSTANT_PURCHASE_INITIATE_TAX_AND_SHIPPING_EVENT = "INSTANT
 export declare const INSTANT_PURCHASE_TAX_AND_SHIPPING_RESPONSE = "INSTANT_PURCHASE_TAX_AND_SHIPPING_RESPONSE";
 export interface InstantPurchaseInitiateTaxAndShippingEventPayload {
     cacheKey: string;
+    requestId?: string;
     totalUpsellPrice: number;
     currency: string;
     upsellItems: UpsellItem[];
@@ -65,6 +68,7 @@ export interface InstantPurchaseTaxAndShippingResponseEnvelope {
 }
 export interface InstantPurchaseTaxAndShippingResponsePayload {
     cacheKey: string;
+    requestId?: string;
     timestamp: string;
     sessionId: string;
     response?: InstantPurchaseTaxAndShippingResponseEnvelope;

package/dist/modules/instant-purchase/src/reducers/catalog-selection/reducer.d.ts

@@ -1,4 +1,6 @@
 import { AnyAction } from '@reduxjs/toolkit';
 import { CatalogSelectionState } from '../../models/state/catalog-selection';
+export type CatalogAttributeSelectionsState = Record<string, string> | null;
+export declare const catalogAttributeSelectionsReducer: (state: CatalogAttributeSelectionsState | undefined, action: AnyAction) => CatalogAttributeSelectionsState;
 export declare function makeInitialCatalogSelectionState(): CatalogSelectionState;
 export declare const catalogReducer: (state: CatalogSelectionState | undefined, action: AnyAction) => CatalogSelectionState;