@elliemae/pui-app-sdk 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/types/lib/utils/decorators/classDecorators.d.ts

@@ -3,6 +3,7 @@
  * @param constructors - The constructors of the classes to be mixed in.
  * @returns A class decorator that mixes the provided classes into the target class.
  * @example
+ * ```typescript
  * class A {
  *   methodA() {
  *     console.log('A');
@@ -14,12 +15,14 @@
  *     console.log('B');
  *   }
  * }
- * @Mixins(A, B)
+ * // Apply decorator
+ * // @Mixins(A, B)
  * class C {}
  *
  * const instance = new C();
  * instance.methodA(); // Outputs: 'A'
  * instance.methodB(); // Outputs: 'B'
+ * ```
  */
 export declare function Mixins(...constructors: any[]): (derivedCtor: any) => void;
 declare const SINGLETON_KEY: unique symbol;
@@ -28,7 +31,8 @@ declare const SINGLETON_KEY: unique symbol;
  * @param type - The class to be made a singleton.
  * @returns A proxy that ensures only one instance of the class is created.
  * @example
- * @Singleton
+ * ```typescript
+ * // @Singleton decorator
  * class MyClass {
  *   constructor() {
  *     console.log('Instance created');
@@ -39,6 +43,7 @@ declare const SINGLETON_KEY: unique symbol;
  * const instance2 = new MyClass(); // No output, same instance returned
  *
  * console.log(instance1 === instance2); // Outputs: true
+ * ```
  */
 export declare function Singleton<T extends new (...args: any[]) => any>(type: T): T & {
     [SINGLETON_KEY]?: InstanceType<T>;

package/dist/types/lib/utils/decorators/functionDecorators.d.ts

@@ -5,12 +5,14 @@
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @CacheUntilResolved
+ *   // Apply decorator: CacheUntilResolved
  *   async fetchData() {
  *     // ...fetch data...
  *   }
  * }
+ * ```
  */
 export declare function CacheUntilResolved(_target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -18,12 +20,14 @@ export declare function CacheUntilResolved(_target: any, propertyKey: string, de
  * @param {number} [delay=300] - The delay in milliseconds.
  * @returns {Function} A function that modifies the property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @Debounce(500)
+ *   // Apply decorator: Debounce(500)
  *   onResize() {
  *     // ...handle resize...
  *   }
  * }
+ * ```
  */
 export declare function Debounce(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
@@ -33,12 +37,14 @@ export declare function Debounce(delay?: number): (_target: any, _propertyKey: s
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @ImmutableArgs
+ *   // Apply decorator: ImmutableArgs
  *   updateData(data: any) {
  *     // ...update data...
  *   }
  * }
+ * ```
  */
 export declare function ImmutableArgs(_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -48,12 +54,14 @@ export declare function ImmutableArgs(_target: any, _propertyKey: string | symbo
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @Memoize
+ *   // Apply decorator: Memoize
  *   computeValue(x: number) {
  *     return x * 2;
  *   }
  * }
+ * ```
  */
 export declare function Memoize(_target: any, _key: string, descriptor: PropertyDescriptor): void;
 /**
@@ -63,12 +71,14 @@ export declare function Memoize(_target: any, _key: string, descriptor: Property
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @MemoizeAsync
+ *   // Apply decorator: MemoizeAsync
  *   async fetchData() {
  *     // ...fetch data...
  *   }
  * }
+ * ```
  */
 export declare function MemoizeAsync(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -78,12 +88,14 @@ export declare function MemoizeAsync(_target: any, _propertyKey: string, descrip
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @QueueTask
+ *   // Apply decorator: QueueTask
  *   processTask() {
  *     // ...process task...
  *   }
  * }
+ * ```
  */
 export declare function QueueTask(_target: unknown, _key: string, descriptor: PropertyDescriptor): void;
 /**
@@ -99,3 +111,111 @@ export declare function QueueTask(_target: unknown, _key: string, descriptor: Pr
  * }
  */
 export declare function Throttle(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * AsyncSingleExecution decorator ensures that multiple concurrent calls to an async function
+ * with the same arguments will return the same promise instance until it resolves.
+ * Once resolved, subsequent calls will trigger a new execution.
+ * @param _target
+ * @param _propertyKey
+ * @param descriptor
+ * @returns {Function} A function that modifies the property descriptor.
+ * @example
+ * ```typescript
+ * import { AsyncSingleExecution } from './functionDecorators';
+ *
+ * class Example {
+ *   @AsyncSingleExecution
+ *   async fetchData(id: number) {
+ *     console.log('Fetching data for', id);
+ *     return new Promise(resolve => setTimeout(() => resolve(id), 1000));
+ *   }
+ * }
+ *
+ * const instance = new Example();
+ * const promise1 = instance.fetchData(1);
+ * const promise2 = instance.fetchData(1);
+ *
+ * console.log(promise1 === promise2); // true
+ * ```
+ *
+ * // Output:
+ * // Fetching data for 1 (only logged once)
+ * ```
+ */
+export declare function AsyncSingleExecution(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Retries an async method a specified number of times with a delay between attempts.
+ * @param {number} [retries=3] - The number of retry attempts.
+ * @param {number} [interval=2000] - The delay in milliseconds between retries.
+ * @param {boolean} [reThrowException=true] - Whether to rethrow the exception after all retries fail.
+ * @returns {MethodDecorator} A method decorator that modifies the property descriptor.
+ * @example
+ * class Example {
+ *   @RetryAsync(3, 1000, true)
+ *   async fetchData() {
+ *     console.log('Attempting to fetch data...');
+ *     if (Math.random() < 0.7) {
+ *       throw new Error('Fetch failed');
+ *     }
+ *     return 'Data fetched successfully';
+ *   }
+ * }
+ *
+ * const instance = new Example();
+ * instance.fetchData().then(console.log).catch(console.error);
+ *
+ * // Output (example):
+ * // Attempting to fetch data...
+ * // Attempting to fetch data...
+ * // Attempting to fetch data...
+ * // Error: Fetch failed
+ */
+export declare function RetryAsync(retries?: number, interval?: number, reThrowException?: boolean): MethodDecorator;
+/**
+ * Memoizes the result of a function with a single primitive argument or no arguments.
+ * Only caches results for functions that take exactly one primitive argument (string, number, boolean, symbol, null, or undefined)
+ * or no arguments at all. Uses a simple object as the cache.
+ * @param _target
+ * @param _propertyKey
+ * @param descriptor
+ * @example
+ * ```typescript
+ * // Single primitive argument
+ * class Example {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   double(x: number) {
+ *     return x * 2;
+ *   }
+ * }
+ * const ex = new Example();
+ * ex.double(2); // Calls original, returns 4
+ * ex.double(2); // Returns cached result, 4
+ * ```
+ * @example
+ * ```typescript
+ * // No arguments
+ * class ExampleNoArg {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   getRandom() {
+ *     return Math.random();
+ *   }
+ * }
+ * const ex2 = new ExampleNoArg();
+ * ex2.getRandom(); // Calls original, returns a value
+ * ex2.getRandom(); // Returns cached value
+ * ```
+ * @example
+ * ```typescript
+ * // Not cached for non-primitive or multiple arguments
+ * class ExampleObj {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   sum(obj: { x: number }) {
+ *     return obj.x + 1;
+ *   }
+ * }
+ * const ex3 = new ExampleObj();
+ * ex3.sum({ x: 1 }); // Calls original
+ * ex3.sum({ x: 1 }); // Calls original again (not cached)
+ * ```
+ */
+export declare function MemoizeSingleArgPrimitive<T extends string | number | boolean | symbol | null | undefined, R>(_target: any, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => R>): TypedPropertyDescriptor<(...args: any[]) => R>;

package/dist/types/lib/utils/decorators/index.d.ts

@@ -1,5 +1,5 @@
 import { Mixins, Singleton } from './classDecorators.js';
-import { CacheUntilResolved, Debounce, ImmutableArgs, Memoize, MemoizeAsync, QueueTask, Throttle } from './functionDecorators.js';
+import { AsyncSingleExecution, CacheUntilResolved, Debounce, ImmutableArgs, Memoize, MemoizeAsync, QueueTask, Throttle, RetryAsync, MemoizeSingleArgPrimitive } from './functionDecorators.js';
 declare const decorators: {
     class: {
         Mixins: typeof Mixins;
@@ -11,8 +11,11 @@ declare const decorators: {
         ImmutableArgs: typeof ImmutableArgs;
         Memoize: typeof Memoize;
         MemoizeAsync: typeof MemoizeAsync;
+        MemoizeSingleArgPrimitive: typeof MemoizeSingleArgPrimitive;
         QueueTask: typeof QueueTask;
         Throttle: typeof Throttle;
+        AsyncSingleExecution: typeof AsyncSingleExecution;
+        RetryAsync: typeof RetryAsync;
     };
 };
 export { decorators };

package/dist/types/lib/utils/helpers.d.ts

@@ -12,3 +12,10 @@ export declare const getProductAppDetails: () => {
     appUrl: string;
     appPageTitle: string;
 };
+export declare const abortPromise: ({ promise, delay, retValue, throwError, errMsg, }: {
+    promise: Promise<unknown>;
+    delay: number;
+    retValue?: unknown;
+    throwError?: boolean;
+    errMsg?: string;
+}) => Promise<unknown>;

package/dist/types/lib/utils/logrocket.d.ts

@@ -0,0 +1,26 @@
+import type LogRocket from 'logrocket';
+import { resetLrIdentity } from '@elliemae/pui-analytics-so';
+export { resetLrIdentity };
+export declare const getLogRocket: () => typeof LogRocket | undefined;
+/**
+ * Send user identification events to LogRocket.
+ * Also marks analytics-so as identified so its internal
+ * {@link ensureLrIdentified} does not re-identify.
+ * @param {string} userId user identifier
+ * @param {Record<string, any>} eventEx event meta data
+ */
+export declare const lrIdentify: (userId: string, eventEx: Record<string, any>) => void;
+/**
+ * Throttled LogRocket track call. Delegates to analytics-so's
+ * {@link lrTrackGuarded} which applies sliding-window throttle and
+ * property-count warnings. Only caller-supplied fields are sent — no
+ * ambient context — to conserve LogRocket's 2,000 total-property session
+ * budget.
+ *
+ * analytics-so automatically ensures the user is identified to LogRocket
+ * (from sessionStorage) before the first track call, covering session
+ * restore, token refresh, and late-loading LogRocket scenarios.
+ * @param {string} event event name
+ * @param {Record<string, any>} eventEx caller-supplied event properties only
+ */
+export declare const lrTrack: (event: string, eventEx?: Record<string, any>) => void;

package/dist/types/lib/utils/micro-frontend/app-bridge.d.ts

@@ -0,0 +1,15 @@
+import { CAppBridge } from '@elliemae/pui-app-bridge';
+import { ScriptingObjectTypes, Events } from '@elliemae/pui-scripting-object';
+import type { ScriptingObjects, EventListeners } from '@elliemae/microfe-common';
+/**
+ * Returns (and lazily initialises) the singleton {@link CAppBridge} instance.
+ *
+ * On first call the bridge is created, initialised with the already-loaded
+ * `appConfig` to avoid a duplicate HTTP fetch, and then {@link CAppBridge.warmUp}
+ * is called for every micro-app listed in `microFrontendApps` so that their
+ * manifests are pre-fetched in the background.
+ * @template AppObjects - Scripting-object type map for the host
+ * @template AppEvents - Event-listener type map for the host
+ * @returns The initialised app-bridge singleton
+ */
+export declare const getAppBridge: <AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events>() => Promise<CAppBridge<Partial<ScriptingObjectTypes>, Events>>;

package/dist/types/lib/utils/micro-frontend/guest.d.ts

@@ -1,8 +1,13 @@
 import { DefaultTheme } from 'styled-components';
 import { History, To } from 'history';
 import type { IMicroAppGuest, IMicroAppHost, InitOptions, MountOptions } from '@elliemae/pui-micro-frontend-base';
+import { SSFHost } from '@elliemae/ssf-host';
+import { ScriptingObjectTypes, Events, ModuleParameters } from '@elliemae/pui-scripting-object';
+import { IMicroFEHost } from '@elliemae/pui-app-bridge';
+import type { ScriptingObjects, EventListeners, SubscribeParam, UnsubscribeParam, DispatchEventParam, EventOptions, AddScriptingObjectParams } from '@elliemae/microfe-common';
+import { SSFGuest } from '@elliemae/ssf-guest';
 import { JSONValue, MicroFrontEndLogger } from '../types.js';
-export interface GuestProps extends InitOptions {
+export interface GuestProps<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events> extends InitOptions<AppObjects, AppEvents> {
     prevState: JSONValue | null;
     history: History;
     theme: DefaultTheme;
@@ -18,8 +23,43 @@ interface ConstructorParams {
     onUnmount?: OnUnMountCallback;
     onGetRef?: OnGetRefCallback;
     history?: History;
+    ssfHostRef?: SSFHost<ScriptingObjectTypes, Events> | null;
+    /**
+     * true if the app prefers to use SSF V2 Guest from App SDK to communicate with host(optional, default: true)
+     */
+    useV2Guest?: boolean;
+    /**
+     * When true the guest drives its own lifecycle via initialize().
+     * Skips registering init/mount/unmount on the parent window —
+     * the bridge will not call these methods.
+     */
+    selfInitialize?: boolean;
 }
-export declare class CMicroAppGuest implements IMicroAppGuest {
+/**
+ * Micro-frontend guest application class (singleton).
+ * Manages communication between a guest micro-app and its host application.
+ * Supports both SSF (Shared Service Framework) and App Bridge communication methods.
+ * @template AppObjects - Type of custom scripting objects
+ * @template AppEvents - Type of custom event listeners
+ * @example
+ * ```typescript
+ * const guest = new CMicroAppGuest({
+ *   onInit: ({ history, theme, prevState }) => {
+ *     console.log('Guest initialized');
+ *   },
+ *   onMount: ({ container }) => {
+ *     // Render your React app
+ *     ReactDOM.render(<App />, container);
+ *   },
+ *   onUnmount: ({ container }) => {
+ *     // Cleanup
+ *     ReactDOM.unmountComponentAtNode(container);
+ *     return { savedState: 'some data' };
+ *   }
+ * });
+ * ```
+ */
+export declare class CMicroAppGuest<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events> implements IMicroAppGuest<AppObjects, AppEvents> {
     #private;
     private static instance;
     private readonly logger;
@@ -31,19 +71,59 @@ export declare class CMicroAppGuest implements IMicroAppGuest {
     private readonly onUnmount?;
     private readonly onGetRef?;
     private constructor();
-    static getInstance(params?: ConstructorParams): CMicroAppGuest;
+    static getInstance<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events>(params?: ConstructorParams): CMicroAppGuest<AppObjects, AppEvents>;
     static isInitialized(): boolean;
     static isHosted(): boolean;
-    getHost(): IMicroAppHost | undefined;
+    getHost(): IMicroAppHost<Partial<ScriptingObjectTypes>, Events> | IMicroFEHost<Partial<ScriptingObjectTypes>, Events> | SSFGuest<Partial<ScriptingObjectTypes>, Events> | undefined;
     getLogger(): MicroFrontEndLogger;
-    getProps(): GuestProps;
+    getObject<ObjectId extends Extract<keyof AppObjects, string>>(objectId: ObjectId): Promise<AppObjects[ObjectId] | null>;
+    /**
+     * subscribe to the scripting object event
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} params - the parameters for the subscription
+     * @param {string} params.soName - the name of the scripting object
+     * @param {string} params.eventName - the name of the event
+     * @param {Function} params.callback - the callback function to be called when the event is triggered
+     * @returns {void}
+     */
+    subscribe<EventId extends Extract<keyof AppEvents, string>>(params: SubscribeParam<EventId, AppEvents[EventId]>): string;
+    /**
+     * unsubscribe from the scripting object event
+     * @param params - parameters for the unsubscription
+     */
+    unsubscribe<EventId extends Extract<keyof AppEvents, string>>(params: UnsubscribeParam<EventId>): void;
+    getProps(): GuestProps<Partial<ScriptingObjectTypes>, Events>;
     private getSessionStorageItem;
-    private getSSFAdapter;
+    private findHost;
     get uuid(): string;
-    init(this: CMicroAppGuest, options: InitOptions): Promise<void>;
-    mount(this: CMicroAppGuest, options?: MountOptions): Promise<void>;
-    unmount(this: CMicroAppGuest, options: MountOptions): Promise<JSONValue>;
-    getRef<T>(this: CMicroAppGuest): T | null;
-    navigate(this: CMicroAppGuest, url: To, state?: any): void;
+    /**
+     * Guest-initiated lifecycle: discovers the host, pulls module parameters,
+     * and applies them. After this resolves the guest is ready to render.
+     * Requires selfInitialize: true in the constructor so the bridge
+     * skips calling init() / mount() on this guest.
+     * @returns module parameters provided by the host
+     */
+    initialize(): Promise<ModuleParameters>;
+    init(options: InitOptions<AppObjects, AppEvents>): Promise<void>;
+    mount(options?: MountOptions): Promise<void>;
+    unmount(options: MountOptions): Promise<JSONValue>;
+    getRef<T>(): T | null;
+    navigate(url: To, state?: any): void;
+    /**
+     * add scripting object for child microapp to use
+     * @param so - The scripting object to be added.
+     * @param params - Optional parameters for adding the scripting object.
+     */
+    addScriptingObject<SO extends AppObjects[keyof AppObjects]>(so: SO, params?: AddScriptingObjectParams): void;
+    /**
+     * Dispatches an event to the child microapp.
+     * @param {DispatchEventParam<EventId, Params, Options>} params - Event parameters.
+     * @returns {Promise<any[]>} A promise that resolves with the combined results of dispatched events.
+     */
+    dispatchEvent<EventId extends Extract<keyof AppEvents, string>, Params extends Parameters<AppEvents[EventId]>[0]['eventParams'], Options extends EventOptions>(params: DispatchEventParam<EventId, Params, Options>): Promise<void | unknown[]>;
+    /**
+     * removes scripting object from child microapp use
+     * @param objectId unique id of the scripting object
+     */
+    removeScriptingObject(objectId: Extract<keyof AppObjects, string>): void;
 }
 export {};

package/dist/types/lib/utils/micro-frontend/host.d.ts

@@ -1,10 +1,11 @@
 import { History, To } from 'history';
 import { DefaultTheme } from 'styled-components';
 import { IMicroAppHost, ResizeEventHandler, BreakpointChangeEventHandler, SubscriptionListener } from '@elliemae/pui-micro-frontend-base';
-import ssfHost from '@elliemae/em-ssf-host';
-import { BAEvent } from '@elliemae/pui-scripting-object';
+import { SSFHost } from '@elliemae/ssf-host';
+import { BAEvent, ScriptingObjectTypes, Events } from '@elliemae/pui-scripting-object';
+import type { ScriptingObjects, EventListeners, AddScriptingObjectParams, DispatchEventParam, EventOptions } from '@elliemae/microfe-common';
+import { Analytics } from '@elliemae/pui-analytics-so';
 import { MicroFrontEndLogger } from '../types.js';
-import { Analytics } from './scripting-objects/analytics.js';
 type HostOptions = {
     systemVersion: string;
     history: History;
@@ -19,10 +20,30 @@ type ConstructorParams = {
     scriptingObjects?: Record<string, any>;
     onRenewSessionTimer?: () => void;
     onInit?: OnInitCallback;
-    ssfHostRef?: typeof ssfHost.Host;
+    ssfHostRef?: SSFHost<ScriptingObjectTypes, Events> | null;
     analytics?: Analytics;
 };
-export declare class CMicroAppHost implements IMicroAppHost {
+/**
+ * Micro-frontend host application class (singleton).
+ * Manages hosting and coordination of multiple micro-frontend guest applications.
+ * Provides shared services like navigation, theming, analytics, and state management.
+ * @template AppObjects - Type of custom scripting objects
+ * @template AppEvents - Type of custom event listeners
+ * @example
+ * ```typescript
+ * const host = new CMicroAppHost({
+ *   version: '1.0.0',
+ *   history: browserHistory,
+ *   onInit: ({ history, theme }) => {
+ *     console.log('Host initialized');
+ *   },
+ *   scriptingObjects: {
+ *     customService: new CustomService()
+ *   }
+ * });
+ * ```
+ */
+export declare class CMicroAppHost<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events> implements IMicroAppHost<AppObjects, AppEvents> {
     #private;
     private static instance;
     private readonly logger;
@@ -31,27 +52,28 @@ export declare class CMicroAppHost implements IMicroAppHost {
     activeGuests: Record<string, unknown>;
     private readonly onInit?;
     private readonly onRenewSessionTimer?;
+    private readonly throttleRenewSessionTimer;
     scriptingObjects: Record<string, any>;
     private constructor();
-    static getInstance(params?: ConstructorParams): CMicroAppHost;
+    static getInstance<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events>(params?: ConstructorParams): CMicroAppHost<AppObjects, AppEvents>;
     static isInitialized(): boolean;
-    getProps(this: CMicroAppHost): HostOptions;
-    getLogger(this: CMicroAppHost): MicroFrontEndLogger;
+    getProps(): HostOptions;
+    getLogger(): MicroFrontEndLogger;
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
-    getGuests(this: CMicroAppHost): Record<string, unknown>;
+    getGuests(): Record<string, unknown>;
     getGuest<T>(id: string): T | null;
     publish<Type>(message: string | symbol, data?: Type): boolean;
     subscribe<T>(message: string | symbol, func: SubscriptionListener<T>): string;
     unsubscribe(token: string): void;
-    navigate(this: CMicroAppHost, url: To, state?: any): void;
+    navigate(url: To, state?: any): void;
     openWaitMessage(): void;
     closeWaitMessage(): void;
     openErrorBanner(message: string): void;
     getAuthToken(): string;
     renewAuthToken(): string;
     logout(): void;
-    renewSessionTimer(this: CMicroAppHost): Promise<void>;
+    renewSessionTimer(): Promise<void>;
     getBreakpoint(): keyof import("@elliemae/pui-theme").BreakPoints;
     getViewportSize(): {
         width: number;
@@ -62,5 +84,22 @@ export declare class CMicroAppHost implements IMicroAppHost {
     setSystemVersion(version?: string): void;
     sendBAEvent(data: BAEvent): void;
     getObject<T>(name: string): Promise<T>;
+    /**
+     * add scripting object for child microapp to use
+     * @param so - The scripting object to be added.
+     * @param params - Optional parameters for adding the scripting object.
+     */
+    addScriptingObject<SO extends AppObjects[keyof AppObjects]>(so: SO, params?: AddScriptingObjectParams): void;
+    /**
+     * dispatch event to child microapp
+     * @param {DispatchEventParams<EventId, Params>} params - event parameters
+     * @returns {Promise<any>} A promise that resolves with the combined results of dispatched events.
+     */
+    dispatchEvent<EventId extends Extract<keyof AppEvents, string>, Params extends Parameters<AppEvents[EventId]>[0]['eventParams'], Options extends EventOptions>(params: DispatchEventParam<EventId, Params, Options>): Promise<void | unknown[]>;
+    /**
+     * removes scripting object from child microapp use
+     * @param objectId unique id of the scripting object
+     */
+    removeScriptingObject(objectId: Extract<keyof AppObjects, string>): void;
 }
 export {};

package/dist/types/lib/utils/micro-frontend/module-so.d.ts

@@ -0,0 +1,82 @@
+import { History, To } from 'history';
+import { DefaultTheme } from 'styled-components';
+import { ScriptingObject, Event } from '@elliemae/ssf-host';
+import { IModule, ModuleParameters, Events, LogLevels, LogMessage } from '@elliemae/pui-scripting-object';
+/**
+ * Host-provided values that can't be read from the app config.
+ */
+export type HostProvidedParams = {
+    /** Host-provided history object (by reference, App Bridge only — not for SSF) */
+    history?: History;
+    /** Styled-components theme */
+    theme?: DefaultTheme;
+    /** Route to navigate to on open (only when useParentHistory is false) */
+    initialRoute?: To;
+    /** Additional host-defined key-value pairs */
+    [key: string]: unknown;
+};
+/**
+ * Build a {@link ModuleParameters} object for a self-initializing guest.
+ *
+ * Reads `hostUrl`, `manifestPath`, and `homeRoute` from the app config
+ * for the given guest id. The host only provides values the config
+ * doesn't have: `theme`, `history`, and optionally `initialRoute`.
+ * @param guestId - App id as defined in app.config.json (e.g. 'loanapp')
+ * @param params - Host-provided values (theme, history, initialRoute, custom keys)
+ * @returns ModuleParameters ready for getParameters()
+ */
+export declare const buildModuleParams: (guestId: string, params?: HostProvidedParams) => ModuleParameters;
+/**
+ * Default IModule implementation backed by a static parameters object.
+ * Hosts can instantiate this directly or use the {@link createGuestModule}
+ * factory for a terser API.
+ */
+export declare class GuestModule extends ScriptingObject implements IModule {
+    #private;
+    constructor(guestId: string, params?: HostProvidedParams);
+    readonly Close: Event<Events>;
+    readonly Unloading: Event<Events>;
+    /**
+     * Bind the teardown logic that runs when the guest calls unload().
+     * Prefixed with _ so SSF's for…in discovery skips it.
+     * The App Bridge auto-binds this in openApp().
+     * @param handler
+     */
+    _setUnloadHandler(handler: () => Promise<void>): void;
+    getParameters(): Promise<ModuleParameters>;
+    getCapabilities(): Promise<Record<string, unknown>>;
+    log(message: LogMessage | string, logLevel: keyof typeof LogLevels): Promise<void>;
+    unload(): Promise<void>;
+}
+/**
+ * Optional method overrides the host can supply to customise
+ * the module scripting object beyond the defaults.
+ *
+ * Typed keys shadow the corresponding {@link GuestModule} methods.
+ * The index signature allows adding host-specific methods that the
+ * guest can discover through the scripting object protocol.
+ *
+ * Overrides are applied via Object.assign so they become own
+ * enumerable properties on the instance — required for SSF's
+ * _toJSON discovery (for…in enumeration).
+ */
+export type ModuleOverrides = {
+    getCapabilities?: () => Promise<Record<string, unknown>>;
+    log?: (message: LogMessage | string, logLevel: keyof typeof LogLevels) => Promise<void>;
+    unload?: () => Promise<void>;
+    [method: string]: ((...args: any[]) => any) | undefined;
+};
+/**
+ * Create a module scripting object for a guest micro-app.
+ * The host registers this before rendering GuestMicroApp so the guest
+ * can pull its init parameters via module.getParameters().
+ *
+ * Internally calls {@link buildModuleParams} to merge the app config
+ * values (hostUrl, manifestPath, homeRoute) with host-provided values
+ * (theme, history, initialRoute).
+ * @param guestId - App id as defined in app.config.json (e.g. 'loanapp')
+ * @param params - Host-provided values (theme, history, initialRoute, custom keys)
+ * @param overrides - Method overrides / additions (e.g. custom getCapabilities)
+ * @returns IModule scripting object ready for addScriptingObject()
+ */
+export declare const createGuestModule: (guestId: string, params?: HostProvidedParams, overrides?: ModuleOverrides) => IModule;

package/dist/types/lib/utils/micro-frontend/ssf-host.d.ts

@@ -0,0 +1,5 @@
+import { SSFHost } from '@elliemae/ssf-host';
+import { ScriptingObjectTypes, Events } from '@elliemae/pui-scripting-object';
+import type { ScriptingObjects, EventListeners } from '@elliemae/microfe-common';
+export declare const getSSFHost: <AppObjects extends ScriptingObjects = ScriptingObjectTypes, AppEvents extends EventListeners = Events>() => SSFHost<AppObjects, AppEvents>;
+export declare const setSSFHost: (host: SSFHost<any, any>) => void;

package/dist/types/lib/utils/micro-frontend/tests/guest-initialize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/micro-frontend/tests/host.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/utils/micro-frontend/tests/module-so.test.d.ts

@@ -0,0 +1 @@
+export {};