@rokt/dcui-orchestrator 1.2.1-rc.6 → 1.2.1-rc.61

package/dist/libraries/domain/src/models/form-state.d.ts

@@ -83,3 +83,88 @@ export interface FormFieldRef {
  * ActionButton (to gate dispatch) so both resolve entries identically.
  */
 export declare function resolveFormFieldRefs(formStates: FormStatesState, entries: string[]): FormFieldRef[];
+/**
+ * The longest `Pattern` a layout may register. A longer one is refused by
+ * {@link scanPattern}: the form-state reducer drops it at registration and
+ * {@link matchesPattern} treats it as non-blocking.
+ */
+export declare const MAX_PATTERN_LENGTH = 256;
+/**
+ * The longest value a `Pattern` validation tests, whatever the pattern. A
+ * longer value fails the validation with its message, untested. The rules of
+ * {@link scanPattern} bound the engine's work on a value of this length and
+ * on no other.
+ */
+export declare const MAX_PATTERN_VALUE_LENGTH = 512;
+/** Why {@link scanPattern} refused a pattern: the first rule it broke. */
+export type PatternRefusal = 'too-long' | 'backreference' | 'nested-quantifier' | 'repeated-alternation' | 'quantified-lookaround' | 'too-many-repetitions' | 'count-too-wide' | 'too-many-ways' | 'too-many-steps' | 'invalid';
+/** What {@link scanPattern} read: the verdict, with a refusal's reason. */
+export type PatternScan = {
+    safe: true;
+} | {
+    safe: false;
+    reason: PatternRefusal;
+};
+/**
+ * The walk behind {@link isSafePattern}: one pass over the pattern's syntax,
+ * with no reading of what the atoms match. Escapes and `[...]` classes are
+ * one token each, so a `(`, `|` or `*` inside them is literal. The rules are
+ * blunt by design: each refuses a shape that can backtrack past the value
+ * cap, and with it the safe patterns of the same shape. The check that reads
+ * a pattern's real cost belongs at publish time, in the service that stores
+ * the layout. Refused, in the order the rules are read:
+ *
+ * 1. a pattern longer than {@link MAX_PATTERN_LENGTH};
+ * 2. a backreference, `\1` or `\k<name>`;
+ * 3. a repeated group that holds a quantifier of its own, at any depth:
+ *    `(a+)+`, `(\d{3}-?)+`, `(a+){3}`. A `?` or a `{1}` on the group takes
+ *    it whole or not at all, so `(a+)?` is accepted. A fixed count is copies
+ *    of the group in sequence, so `(\d{4}[- ]?){3}` is accepted;
+ * 4. a repeated group that holds a `|`, at any depth: `(a|ab)+`. A fixed
+ *    count is copies here too, so `(?:a|ab){3}` is accepted;
+ * 5. a quantifier on a lookaround, inside one, or on a group that holds
+ *    one: `(?=a)+`, `(?=.*\d)`, `(?:(?=a)b){3}`;
+ * 6. more than {@link MAX_REPETITIONS} repetitions that can run on in the
+ *    whole pattern, or more than {@link MAX_ANCHORED_REPETITIONS} in one
+ *    anchored at `^`: `\w*\w*\w*-`, `^\w*\w*\w*\w*$`, where `^\w*\w*\w*$`
+ *    and `^[^\s@]+@[^\s@]+\.[^\s@]+$` are accepted;
+ * 7. a count past {@link MAX_PATTERN_VALUE_LENGTH}, on its own or multiplied
+ *    through the counts of the groups that hold it: `\w{513}`, `.{0,1000}`,
+ *    `(?:\b){999}`, `(?:(?:\b){512}){512}`;
+ * 8. {@link MAX_WAYS_STEPS} steps or more from the ways alone: each atom's
+ *    count, once per way of the atoms before it. Thirty `a?`, eight
+ *    `\d{1,9}`, `^(?:\d{1,9}){5}\w{467}$` and sixteen `a?` before `\w{495}$`
+ *    are refused, where a phone, card, IPv4 or optional-scheme URL pattern
+ *    is accepted;
+ * 9. {@link MAX_PATTERN_STEPS} steps or more from the ways and the runs
+ *    together: the same sum, each run multiplying the paths to the atoms
+ *    after it by the cap over the run's rank on its own path (its branch
+ *    and the branches of the groups that hold it, never a sibling `|`
+ *    alternative, so the branches of a `|` add up), and a pattern with no
+ *    `^` running from every position. Twelve `a?` before `\w*\w*$`,
+ *    `\w*\w*-`, `^\w*\w*\w{511}$` and `^\w*!|^` with nine `a?` before
+ *    `\w*\w*!` are refused, where `^\w*\w*\w*!`, `\S+@\S+` and `^\S+@\S+$`
+ *    are accepted;
+ * 10. a pattern RegExp rejects, as `(`.
+ *
+ * An accepted pattern is tested on a value of {@link MAX_PATTERN_VALUE_LENGTH}
+ * characters at most; {@link matchesPattern} fails a longer value untested.
+ */
+export declare function scanPattern(pattern: string): PatternScan;
+/**
+ * Whether a layout author's `Pattern` can be tested without hanging the
+ * plugin. The regular expression runs synchronously on the UI thread, inside
+ * a reducer, on every keystroke, and cannot be interrupted, so the only
+ * control is on the pattern's shape before it runs: the rules of
+ * {@link scanPattern}. A `pattern` that is no string is not refused, so a
+ * layout no schema checked still registers, but {@link matchesPattern}
+ * never compiles it.
+ */
+export declare function isSafePattern(pattern: string): boolean;
+/**
+ * Whether a validation may be registered on a field: every validation but a
+ * `Pattern` that {@link isSafePattern} refuses. Shared by the form-state
+ * reducer, which drops the refused ones, and the TextInput, which reports
+ * them, so the two never disagree on what was dropped.
+ */
+export declare function isSafeInputValidation(validation: InputValidation): boolean;

package/dist/libraries/domain/src/models/global-state.d.ts

@@ -16,10 +16,24 @@ export interface GlobalState {
     firedEvents: Partial<Record<LayoutEvent, boolean>>;
     formStates: FormStatesState;
 }
+/**
+ * The catalog choice a host module has made, synced so a child layout can
+ * show it. The child already holds the offer, so only identifiers travel.
+ */
+export interface SyncedCatalogSelection {
+    /** The selected item, or a stacked selector's preview of one; `null` before any choice. */
+    catalogItemId: string | null;
+    /** Chosen option label per attribute id, partial while the shopper is choosing. */
+    attributeSelections: Record<string, string>;
+}
 /**
  * The GlobalState slices a host syncs down to a child layout; `breakpoint`
  * is absent because the child computes its own from its iframe width.
+ * `catalogSelection` is module state, present only when the launching module
+ * has a catalog selection to share.
  */
-export type SyncedGlobalState = Pick<GlobalState, 'progression' | 'customStates' | 'domainStates' | 'firedEvents' | 'formStates'>;
+export type SyncedGlobalState = Pick<GlobalState, 'progression' | 'customStates' | 'domainStates' | 'firedEvents' | 'formStates'> & {
+    catalogSelection?: SyncedCatalogSelection;
+};
 export declare function makeSyncedGlobalState(state?: Partial<SyncedGlobalState>): SyncedGlobalState;
 export declare function makeGlobalState(state?: Partial<GlobalState>): GlobalState;

package/dist/libraries/domain/src/models/index.d.ts

@@ -14,3 +14,4 @@ export * from './interactivity';
 export * from './child-plugin';
 export * from './purchase';
 export * from './shipping';
+export * from './child-layout-response';

package/dist/libraries/domain/src/models/layout/layout-offer.d.ts

@@ -4,6 +4,8 @@ import { LayoutTransactionData } from './layout-transaction-data';
 export interface LayoutOffer {
     campaignId: string;
     accountId: string;
+    /** The rendered ad's id; absent until the transactions API sends it. */
+    adId?: string;
     maxTotalItemsQtyInOffer: number;
     creative: LayoutCreative;
     metadata: Record<string, string>;

package/dist/libraries/domain/src/models/partner-event.d.ts

@@ -1,5 +1,5 @@
 export type CatalogOutboundPartnerEvent = 'V2_CART_ITEM_UPDATED' | 'UPDATE_CART_ITEM_MESSAGE' | 'CART_ITEM_INSTANT_PURCHASE' | 'UPSELL_ITEM_INSTANT_PURCHASE' | 'DELIVERY_DETAILS_SENT';
-export type OfferOutboundPartnerEvent = CatalogOutboundPartnerEvent | 'OFFER_ENGAGEMENT' | 'POSITIVE_ENGAGEMENT' | 'UPSELL_CREATIVE_SENT' | 'REALTIME_OFFER_FULFILLMENT_REFERRAL' | 'REALTIME_OFFER_FULFILLMENT_CONVERSION' | 'REALTIME_OFFER_FULFILLMENT_SUCCESS' | 'INITIATE_INSTANT_PURCHASE_EVENT' | 'INSTANT_PURCHASE_INITIATE_TAX_AND_SHIPPING_EVENT' | 'INITIATE_CART_ITEM_EVENT' | 'PREPARE_DEVICE_PAY_EVENT' | 'INITIATE_DEVICE_PAY_EVENT' | 'ABORT_DEVICE_PAY_EVENT' | 'COMPLETE_DEVICE_PAY_EVENT';
+export type OfferOutboundPartnerEvent = CatalogOutboundPartnerEvent | 'OFFER_ENGAGEMENT' | 'POSITIVE_ENGAGEMENT' | 'UPSELL_CREATIVE_SENT' | 'REALTIME_OFFER_FULFILLMENT_REFERRAL' | 'REALTIME_OFFER_FULFILLMENT_CONVERSION' | 'REALTIME_OFFER_FULFILLMENT_SUCCESS' | 'INITIATE_INSTANT_PURCHASE_EVENT' | 'INSTANT_PURCHASE_INITIATE_TAX_AND_SHIPPING_EVENT' | 'INITIATE_CART_ITEM_EVENT' | 'PREPARE_DEVICE_PAY_EVENT' | 'INITIATE_DEVICE_PAY_EVENT' | 'ABORT_DEVICE_PAY_EVENT' | 'COMPLETE_DEVICE_PAY_EVENT' | 'LEAD_CAPTURE_SUBMITTED';
 export type OutboundPartnerEvent = OfferOutboundPartnerEvent | 'PLACEMENT_CLOSED' | 'PLACEMENT_COMPLETED' | 'PLACEMENT_INTERACTIVE' | 'PLACEMENT_FAILURE';
 export declare function isOutboundPartnerEvent(value: unknown): value is OutboundPartnerEvent;
 export declare function isOfferOutboundPartnerEvent(value: unknown): value is OfferOutboundPartnerEvent;

package/dist/libraries/domain/src/models/plugin/plugin-child-layout-model.d.ts

@@ -3,6 +3,7 @@ import { Fonts } from '@rokt/plugin';
 import { SyncedGlobalState } from '../global-state';
 import { PluginOffer } from './plugin-offer';
 export interface PluginChildLayoutModel<ChildRootLayoutSchema = ChildRootSchemaModel<LayoutSchemaModel, LayoutDisplayPreset, LayoutSettings, WhenPredicate>> {
+    continuousPresentation?: import('../../behaviors/continuous-child').ContinuousIdentity;
     instanceGuid: string;
     childLayoutId: string;
     layoutSchemaVersion: string;

package/dist/libraries/domain/src/models/plugin/plugin-offer.d.ts

@@ -5,6 +5,8 @@ import { TransactionData } from './plugin-transaction-data';
 export interface PluginOffer {
     campaignId: string;
     accountId: string;
+    /** The rendered ad's id; absent until the transactions API sends it. */
+    adId?: string;
     maxTotalItemsQtyInOffer: number;
     creative: PluginCreative;
     metadata: Record<string, string>;

package/dist/libraries/domain/src/models/purchase.d.ts

@@ -62,6 +62,9 @@ export interface ShippingAttributes {
     postalCode: string;
 }
 export interface PrepareDevicePayEventPayload {
+    googlePayConfigJson?: string;
+    googlePayHandlerId?: string;
+    googlePayHandlerVersion?: string;
     stripeAccountId?: string;
     merchantName?: string;
     countryCode?: string;

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,25 +10,41 @@ 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' | '*';
     callback: (...data: Array<unknown>) => void;
 };
 export interface IGateway<State extends object, Action extends object> {
+    /** Latest authoritative cart for this offer during the subscription handoff. */
+    getOfferCart?: () => Array<{
+        cartItemId: string;
+        quantity: number;
+    }>;
     onEvent(...moduleEventListeners: Array<ModuleEventListener>): () => void;
     onGlobalStateChange(callback: (globalState: State) => void): () => void;
     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

@@ -1,9 +1,16 @@
 import { LaunchChildLayout } from '../../../../domain/src/behaviors';
-import { CallEffect, CancelledEffect, ChannelTakeEffect, ForkEffect, PutEffect, RaceEffect, SelectEffect } from 'redux-saga/effects';
+import { CallEffect, CancelEffect, CancelledEffect, ChannelTakeEffect, ForkEffect, PutEffect, RaceEffect, SelectEffect } from 'redux-saga/effects';
 import { GlobalGateway } from '../../../../module-connector/src/main';
-import { Log, PluginOffer } from '../../../../domain/src/models';
+import { Log, PluginOffer, SyncedCatalogSelection } from '../../../../domain/src/models';
 import { BasicObject, ChildPluginInterface } from '@rokt/plugin';
-export declare function launchChildLayout(gateway: GlobalGateway, logger: (log: Log) => void, action: LaunchChildLayout): Generator<PutEffect | CallEffect | SelectEffect | ForkEffect, void, never>;
+/**
+ * Reads a module's catalog selection from its own store. Re-read after every
+ * module action; an unchanged result is not re-sent.
+ */
+export type SelectCatalogSelection = {
+    bivarianceHack(state: unknown): SyncedCatalogSelection;
+}['bivarianceHack'];
+export declare function launchChildLayout(gateway: GlobalGateway, logger: (log: Log) => void, action: LaunchChildLayout, selectCatalogSelection?: SelectCatalogSelection): Generator<PutEffect | CallEffect | SelectEffect | ForkEffect, void, never>;
 type BridgeChannelMessage = {
     kind: 'ready';
 } | {
@@ -13,5 +20,8 @@ type BridgeChannelMessage = {
 export declare function childLayoutBridge(gateway: GlobalGateway, logger: (log: Log) => void, childPlugin: ChildPluginInterface<BasicObject>, offerContext: {
     offer: PluginOffer;
     offerPositionIndex: number | undefined;
-}): Generator<PutEffect | CallEffect | CancelledEffect | RaceEffect<ChannelTakeEffect<BridgeChannelMessage> | CallEffect>, void, never>;
+    childInstanceGuid: string;
+    advanceOnDismiss?: boolean;
+    selectCatalogSelection?: SelectCatalogSelection;
+}): Generator<PutEffect | CallEffect | CancelledEffect | CancelEffect | ForkEffect | SelectEffect | RaceEffect<ChannelTakeEffect<BridgeChannelMessage> | CallEffect>, void, never>;
 export {};

package/dist/libraries/orchestrator/src/actions/global-offer-data-state.d.ts

@@ -1,4 +1,5 @@
 export declare const SET_GLOBAL_OFFER_DATA_CART = "GLOBAL_OFFER_DATA_STATE/SET_CART";
+export declare const RETAIN_PARTNER_CART_ITEM = "GLOBAL_OFFER_DATA_STATE/RETAIN_PARTNER_CART_ITEM";
 export interface SetGlobalOfferDataCart {
     type: typeof SET_GLOBAL_OFFER_DATA_CART;
     payload: SetGlobalOfferDataCartPayload;
@@ -10,4 +11,13 @@ export interface SetGlobalOfferDataCartPayload {
         quantity: number;
     }>;
 }
-export type GlobalOfferDataStateActions = SetGlobalOfferDataCart;
+export interface RetainPartnerCartItem {
+    type: typeof RETAIN_PARTNER_CART_ITEM;
+    payload: RetainPartnerCartItemPayload;
+}
+export interface RetainPartnerCartItemPayload {
+    offerPositionIndex: number;
+    cartItemId: string;
+    quantity: number;
+}
+export type GlobalOfferDataStateActions = SetGlobalOfferDataCart | RetainPartnerCartItem;

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

@@ -29,8 +29,10 @@ export declare const stateActionTypes: {
     readonly UPDATE_GROUP_SIZE: "PROGRESSION/UPDATE_GROUP_SIZE";
     readonly SET_SLOTS: "SLOTS/SET";
     readonly ADD_LOADED_MODULE: "MODULE/ADD_LOADED";
+    readonly UPDATE_CART_LISTENER_COUNT: "MODULE/UPDATE_CART_LISTENER_COUNT";
     readonly SET_DOMAIN_STATE: "DOMAIN_STATES/SET";
     readonly SET_GLOBAL_OFFER_DATA_CART: "GLOBAL_OFFER_DATA_STATE/SET_CART";
+    readonly RETAIN_PARTNER_CART_ITEM: "GLOBAL_OFFER_DATA_STATE/RETAIN_PARTNER_CART_ITEM";
     readonly LAYOUT_UPDATE: "LAYOUT/UPDATE";
     readonly UPDATE_ACTIVE_BREAKPOINT: "BREAKPOINT/UPDATE_ACTIVE";
     readonly INITIALISE_BREAKPOINT: "BREAKPOINT/INITIALISE";

package/dist/libraries/orchestrator/src/actions/module.d.ts

@@ -3,7 +3,15 @@ export type AddLoadedModuleAction = {
     type: typeof ADD_LOADED_MODULE;
     payload: string;
 };
-export type ModuleActions = AddLoadedModuleAction;
+export declare const UPDATE_CART_LISTENER_COUNT = "MODULE/UPDATE_CART_LISTENER_COUNT";
+export type UpdateCartListenerCount = {
+    type: typeof UPDATE_CART_LISTENER_COUNT;
+    payload: {
+        offerPositionIndex: number;
+        delta: 1 | -1;
+    };
+};
+export type ModuleActions = AddLoadedModuleAction | UpdateCartListenerCount;
 export declare const LOAD_MODULES = "MODULE/LOAD";
 export interface LoadModules {
     type: typeof LOAD_MODULES;

package/dist/libraries/orchestrator/src/cart-listener-gateway.d.ts

@@ -0,0 +1,7 @@
+import { GlobalGatewayFactory } from '../../module-connector/src/main';
+import { UpdateCartListenerCount } from './actions';
+/** Track real subscriptions, which outlive DOM collapse, rather than visible slots. */
+export declare function trackCartListeners(factory: GlobalGatewayFactory, dispatch: (action: UpdateCartListenerCount) => void, readCart?: (position: number) => Array<{
+    cartItemId: string;
+    quantity: number;
+}>): GlobalGatewayFactory;

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