@finsemble/finsemble-ui 7.3.0 → 8.0.0-beta.1

package/platform/services/Interop/modules/resolver.js

@@ -0,0 +1,2481 @@
+/**
+ * Notes. Because reducers use Immer, you can't just console.log pieces of your store. You'll get a bunch of proxy
+ * stuff from the WritableDraft<> template. Wrap your data in unImmer() to print it out normally.
+ */
+var _a, _b;
+import { unImmer } from "../../../../common/redux/createReducer";
+import { concatNoDups, INTENT_RESOLVER_CHANNEL, } from "../../../../clients/Interop/types";
+import { selectConnect } from "../selectConnect";
+import { RouterClient } from "../../../../clients/routerClient";
+import { LauncherClient } from "../../../../clients/launcherClient";
+import { Logger } from "../../../../clients/logger";
+import { setActionResult } from "../../../../common/redux/actionIdMapper";
+import { filterForAppAuthorization, filterForClientAuthorization } from "./authorize";
+import { httpGet } from "../../../../common/REST";
+import { authVerify, authVerifyJWT } from "../AuthSignVerify";
+import { getFriendlyName, interopAssertion, uuidsFromWindowName, notifyEndUser } from "./commonUtils";
+import testPoint from "../../../../common/testPoint";
+import { createAction } from "@reduxjs/toolkit";
+import { isEqual } from "lodash";
+import { ResolveError, OpenError } from "@finos/fdc3";
+// Logger errors are also logged to the console, which clutters up the unit test results for error paths, so when running under Node use warnings instead
+if (((_b = (_a = window === null || window === void 0 ? void 0 : window.process) === null || _a === void 0 ? void 0 : _a.release) === null || _b === void 0 ? void 0 : _b.name) === "node") {
+    Logger.error = Logger.warn;
+    Logger.system.error = Logger.system.warn;
+}
+const workspaceUuid = "#Workspace";
+/**
+ *  Return uuids for specified appId
+ *
+ * @param { resolverState, appId }
+ * @returns {string[]}
+ */
+const uuidsFromAppId = ({ resolverState, appId }) => Object.values(resolverState.clients)
+    .filter((client) => client.appId === appId)
+    .map((client) => client.uuid);
+/**
+ * Returns all app definitions for a given appId
+ *
+ * @param appId
+ * @param appDefinitions
+ * @returns appName for the given appId (or "unknown-appName" if unique match not found)
+ */
+const appsForAppId = (appId, appDefinitions) => Object.values(appDefinitions).filter((definition) => definition.appId === appId);
+/**
+ * Return appId for a given appName; to prevent security hole, return nothing unless there is a unique match for the name
+ *
+ * @param appName
+ * @param appDefinitions
+ * @returns appId for the given appName or null if not a unique match
+ */
+const getValidatedAppIdForAppName = (appName, appDefinitions) => {
+    let appId = null;
+    let matchingApps = Object.values(appDefinitions).filter((definition) => definition.name === appName);
+    if (matchingApps.length === 1) {
+        ({ appId } = matchingApps[0]);
+    }
+    return appId;
+};
+/**
+ * Return appId for specified target
+ *
+ * @param appDefinitions
+ * @param target
+ * @returns appId or null
+ */
+const appIdFromTargetApp = (appDefinitions, target) => {
+    let appId;
+    if (typeof target === "string") {
+        appId = getValidatedAppIdForAppName(target, appDefinitions);
+    }
+    else {
+        if (target.appId) {
+            ({ appId } = target);
+        }
+        else {
+            appId = getValidatedAppIdForAppName(target.name, appDefinitions);
+        }
+    }
+    return appId;
+};
+/**
+ * Returns a set of channels against which to apply an action, given the joinedChannels of a client and the channel requested
+ * 	(1) the specified channel, (2) all joined channels (if no channel was specified), or (3) "global" (if no channels were joined)
+ */
+// const targetedChannels = (state: ResolverStore, joinedChannels: string[], channel?: string): string[] =>
+// 	channel ? [channel] : joinedChannels.length ? joinedChannels : ["global"];
+const actions = {
+    clientAdded: createAction("resolver/clientAdded"),
+    clientRemoved: createAction("resolver/clientRemoved"),
+    register: createAction("resolver/register"),
+    completeRegistration: createAction("resolver/completeRegistration"),
+    heartbeat: createAction("resolver/heartbeat"),
+    cleanupAndVerify: createAction("resolver/cleanupAndVerify"),
+    unregister: createAction("resolver/unregister"),
+    broadcast: createAction("resolver/broadcast"),
+    subscribeContext: createAction("resolver/subscribeContext"),
+    unsubscribeContext: createAction("resolver/unsubscribeContext"),
+    joinChannels: createAction("resolver/joinChannels"),
+    leaveChannels: createAction("resolver/leaveChannels"),
+    sendMessageToDestinations: createAction("resolver/sendMessageToDestinations"),
+    sendSelectConnectMessagesToDestinations: createAction("resolver/sendSelectConnectMessagesToDestinations"),
+    registerSelectConnectChannel: createAction("resolver/registerSelectConnectChannel"),
+    open: createAction("resolver/open"),
+    raiseIntent: createAction("resolver/raiseIntent"),
+    subscribeIntent: createAction("resolver/subscribeIntent"),
+    unsubscribeIntent: createAction("resolver/unsubscribeIntent"),
+    addAppDefinitions: createAction("resolver/addAppDefinitions"),
+    removeAppDefinitions: createAction("resolver/removeAppDefinitions"),
+    handleUIResolutionResponse: createAction("resolver/handleUIResolutionResponse"),
+    openedApp: createAction("resolver/openedApp"),
+    registerUIResolver: createAction("resolver/registerUIResolver"),
+    setInteropRegistrationData: createAction("resolver/setInteropRegistrationData"),
+    resetDetectedLoopState: createAction("resolver/resetDetectedLoopState"),
+    addIntentListenerMaxInitializationTimeout: createAction("resolver/addIntentListenerMaxInitializationTimeout"),
+};
+/**
+ * Removes any object entries that are explicitly "undefined" or null.
+ * We use this in the broadcast loop detection algorithm.
+ */
+const removeEmpty = (obj) => {
+    if (typeof obj !== "object" || obj === null)
+        return obj;
+    let newObj = {};
+    Object.keys(obj).forEach((key) => {
+        if (obj[key] === Object(obj[key]))
+            newObj[key] = removeEmpty(obj[key]);
+        else if (obj[key] !== undefined && obj[key] !== null)
+            newObj[key] = obj[key];
+    });
+    return newObj;
+};
+/**
+ * Filters out intent recipients that are unauthorized as a result of an `authorize` rule.
+ */
+const filterUnauthorizedRecipients = ({ which, candidates, state, uuid, intentName, contextType, }) => {
+    // Reduce our candidate lists down to arrays of strings (destinations) that can be checked by the SelectConnect `authorize` rule.
+    const destinations = candidates.map((candidate) => { var _a, _b; return (_b = (_a = candidate.uuid) !== null && _a !== void 0 ? _a : candidate.meta.appId) !== null && _b !== void 0 ? _b : candidate.meta.name; });
+    // Retrieve the authorized destinations by running them through the `authorize` rule.
+    const authorizedDestinations = which === "apps"
+        ? filterForAppAuthorization({
+            state,
+            originClientUuid: uuid,
+            intentType: intentName,
+            contextType: contextType || "",
+            destinationAppIdList: destinations,
+        })
+        : filterForClientAuthorization({
+            state,
+            originClientUuid: uuid,
+            intentType: intentName,
+            contextType: contextType || "",
+            destinationClientUuidList: destinations,
+        });
+    // Use the authorized destination lists to rebuild and return the candidate list with only authorized candidates.
+    return candidates.filter((candidate) => {
+        var _a, _b;
+        const identifier = (_b = (_a = candidate.uuid) !== null && _a !== void 0 ? _a : candidate.meta.appId) !== null && _b !== void 0 ? _b : candidate.meta.name;
+        return authorizedDestinations.includes(identifier);
+    });
+};
+/**
+ * TargetApp is either a string or an AppMetadata which contains appId and name members. This
+ * function returns true when the provided appName matches the target as a string or
+ * the provided appName and appId matches the AppMetaData.
+ *
+ * For convenience, if target is null or undefined then this will always return false.
+ */
+const targetMatch = (appName, appId, target) => {
+    if (!target)
+        return false;
+    if (typeof target === "string")
+        return appName === target;
+    return appId === target.appId && appName === target.name;
+};
+/**
+ * Gets all of the clients who have called `addIntentListener()` for the given intent.
+ */
+const getRunningAppsForIntent = ({ state, intent, target, }) => Object.values(state.resolver.clients).flatMap((client) => {
+    var _a, _b;
+    if (intent && client.subscriptions.globals.intents[intent]) {
+        if (!target || targetMatch(client.appName, client.appId, target)) {
+            return [
+                {
+                    uuid: client.uuid,
+                    windowName: client.windowName,
+                    meta: {
+                        appId: client.appId,
+                        name: (_a = state.resolver.apps.definitions[client.appId]) === null || _a === void 0 ? void 0 : _a.name,
+                        title: (_b = state.resolver.apps.definitions[client.appId]) === null || _b === void 0 ? void 0 : _b.title,
+                    },
+                    appId: client.appId,
+                },
+            ];
+        }
+        else {
+            return [];
+        }
+    }
+    else {
+        return [];
+    }
+});
+/**
+ * Utility function to return list of intents after combining an appD definition's intents with intents in store.
+ */
+const appendedIntentData = (resolverState, appDDefinition) => {
+    let currentIntents = unImmer(resolverState.intents);
+    if (appDDefinition.intents) {
+        appDDefinition.intents.forEach((intentDef) => {
+            const key = appDDefinition.appId;
+            if (!currentIntents[intentDef.name]) {
+                let launchableHandlers = {};
+                launchableHandlers[key] = null;
+                currentIntents[intentDef.name] = {
+                    info: {
+                        name: intentDef.name,
+                        displayName: intentDef.displayName,
+                    },
+                    launchableHandlers,
+                };
+            }
+            else {
+                currentIntents[intentDef.name].launchableHandlers[key] = null;
+            }
+            const intentElement = currentIntents[intentDef.name];
+            if (intentDef.contexts) {
+                intentDef.contexts.forEach((contextName) => {
+                    intentElement.launchableHandlers[key] = concatNoDups(intentElement.launchableHandlers[key], contextName);
+                });
+            }
+            Logger.system.debug("Interop.resolver.appendedIntentData", intentElement, currentIntents);
+        });
+    }
+    return currentIntents;
+};
+// Utility function to return an array of intentData elements filtered by context (if provided)
+export const filterIntentsByContext = (intentsData, context) => Object.values(intentsData).filter((element) => {
+    // return true to keep the intent (don't filter it); return false to not keep the intent (filter it)
+    // if no context type then don't filter this intent
+    if (!(context === null || context === void 0 ? void 0 : context.type))
+        return true;
+    // if no launchable handlers to match context, then filter this intent
+    if (!element.launchableHandlers)
+        return false;
+    // if one of the supported apps for this intent can handle the specified context type, then don't filter this intent
+    for (const appContextList of Object.values(element.launchableHandlers)) {
+        // if no contexts specified, then it's essentially a wildcard match, so don't filter
+        if (!appContextList)
+            return true;
+        // if the input context matches one in the list, then don't filter
+        if (appContextList.find((contextType) => contextType === context.type))
+            return true;
+    }
+    return false;
+});
+// Utility function to strip from intent handlers the apps that don't handle the specified context.
+// May optionally filter apps if not launchable or a singleton that is already open
+// Also remove an intent from the array if all it's launchableHandler's apps have been filtered.
+export const filterAppHandlersFromIntents = ({ resolverState, intents, context, target, filterNotLaunchable, filterOpenSingletons, }) => {
+    // Intents are readonly so create a mutable clone to modify and return
+    intents = unImmer(intents);
+    intents.forEach((intentElement) => {
+        var _a, _b, _c;
+        for (const [appId, contextList] of Object.entries(intentElement.launchableHandlers)) {
+            const unscrubbedConfig = resolverState.apps.definitions[appId].manifest;
+            // Refactor this when we make appd entries have launchableByUser default to true
+            const launchableByUser = (_b = (_a = unscrubbedConfig === null || unscrubbedConfig === void 0 ? void 0 : unscrubbedConfig.foreign) === null || _a === void 0 ? void 0 : _a.components["App Launcher"]) === null || _b === void 0 ? void 0 : _b.launchableByUser;
+            const openInstances = uuidsFromAppId({ resolverState, appId }).length > 0;
+            const singleton = (_c = unscrubbedConfig === null || unscrubbedConfig === void 0 ? void 0 : unscrubbedConfig.component) === null || _c === void 0 ? void 0 : _c.singleton;
+            if (target && !targetMatch(resolverState.apps.definitions[appId].name, appId, target)) {
+                // since app doesn't match target, remove it from list
+                delete intentElement.launchableHandlers[appId];
+            }
+            else if (filterNotLaunchable && !launchableByUser) {
+                // since app isn't launchable and there is no open instance
+                Logger.system.debug("Interop.resolver.filterAppHandlersFromIntents filtered as non-launchable", appId);
+                delete intentElement.launchableHandlers[appId];
+            }
+            else if (filterOpenSingletons && singleton && openInstances) {
+                // since app is a singleton and it's already open, remove it from list
+                Logger.system.debug("Interop.resolver.filterAppHandlersFromIntents filtered as singleton", appId);
+                delete intentElement.launchableHandlers[appId];
+            }
+            else if (!context || !contextList) {
+                // do nothing -- no context implies a wildcard -- all contexts are excepted
+            }
+            else if (!contextList.includes(context.type)) {
+                // since app doesn't include context, remove it from list
+                delete intentElement.launchableHandlers[appId];
+            }
+            else {
+                // app includes context, but filter out any other contexts
+                intentElement.launchableHandlers[appId] = contextList.filter((appContext) => appContext == context.type);
+            }
+        }
+    });
+    // filter out any of the intents that no longer have at least one launchable handler
+    intents = intents.filter((intentElement) => Object.keys(intentElement.launchableHandlers).length > 0);
+    return intents;
+};
+// Utility function to find a set of intents for a given context. If the intentName is specified then the corresponding intent is the only one returned.
+// Note the intent list will be filtered to only include apps that can handle the context.
+export const findAndFilterAppIntents = ({ resolverState, intentName, context, target, filterNotLaunchable, filterOpenSingletons, originUuid, }) => {
+    let appIntents = [];
+    const intentsData = unImmer(resolverState.intents);
+    // filter intents by the specified context
+    // This is redundant because filterAppHandlersFromIntents already filters it out?
+    const intentsFilteredByContext = filterIntentsByContext(intentsData, context);
+    // strip from intent handlers the apps that don't support the specified context, don't match target, or aren't launchable.
+    const strippedIntents = filterAppHandlersFromIntents({
+        resolverState,
+        intents: intentsFilteredByContext,
+        context,
+        target,
+        filterNotLaunchable,
+        filterOpenSingletons,
+    });
+    // Filter out unauthorized apps
+    let intentData = [];
+    if (intentName) {
+        // after filtering and stripping the intents by context, find the first one that matches theIntentName
+        const oneResult = strippedIntents.find((intentElement) => intentElement.info.name === intentName);
+        if (oneResult) {
+            intentData.push(oneResult);
+        }
+    }
+    else {
+        intentData = strippedIntents;
+    }
+    appIntents = intentData
+        .map((resolverIntent) => {
+        let apps = Object.keys(resolverIntent.launchableHandlers).map((key) => {
+            var _a;
+            const definition = resolverState.apps.definitions[key];
+            return definition
+                ? {
+                    appId: (_a = definition.appId) !== null && _a !== void 0 ? _a : key,
+                    name: definition.name,
+                    title: definition.title,
+                    version: definition.version,
+                    description: definition.description,
+                }
+                : {
+                    appId: key,
+                    name: key,
+                };
+        });
+        if (originUuid) {
+            const authorizedApps = filterForAppAuthorization({
+                state: { resolver: resolverState },
+                originClientUuid: originUuid,
+                destinationAppIdList: apps.map((app) => app.appId || app.name),
+                contextType: (context === null || context === void 0 ? void 0 : context.type) || "",
+            });
+            apps = apps.filter((app) => (app.appId && authorizedApps.includes(app.appId)) || authorizedApps.includes(app.name));
+        }
+        return {
+            intent: resolverIntent.info,
+            apps,
+        };
+    })
+        // Filter out any appIntents that don't have any apps attached to them
+        // (happens when a given intent contains some apps, but none of them are authorized)
+        .filter((appIntent) => appIntent.apps.length > 0);
+    Logger.system.debug("Interop.resolver.findAndFilterAppIntents", {
+        intentName,
+        appIntents,
+        intentData,
+        intentsData,
+        intentsFilteredByContext,
+        strippedIntents,
+    });
+    return appIntents;
+};
+export const sendMessageOnRouter = async (routerChannel, message) => {
+    Logger.system.debug("Interop.resolver.sendMessageOnRouter", routerChannel, message);
+    RouterClient.query(routerChannel, unImmer(message), () => { });
+};
+/**
+ * Performs a very simple check to see if a broadcasted context is a duplicate - the result of a potential infinite
+ * broadcast loop. If the app's current context is the same as its broadcasted context then it's suspect. But it's still
+ * possible for users or developers to intentionally resend an app's current context, so we only say it's a duplicate
+ * if this occurs within 100 milliseconds (since FDC3 is supposed to operate at human speeds).
+ */
+export const isDupBroadcast = (currentContext, broadcastedContext) => {
+    var _a;
+    const timeframe = 100;
+    const lastUpdated = (_a = currentContext === null || currentContext === void 0 ? void 0 : currentContext.meta) === null || _a === void 0 ? void 0 : _a.timestamp;
+    return (lastUpdated &&
+        Date.now() - lastUpdated < timeframe &&
+        isEqual(removeEmpty(currentContext === null || currentContext === void 0 ? void 0 : currentContext.context), removeEmpty(broadcastedContext)));
+};
+/**
+ * Associates the provided context with the app's set of current contexts. This saved context represents the currently
+ * assigned context for that app. This is used to detect broadcast loops.
+ */
+export const saveCurrentContext = (currentContexts, context) => {
+    var _a;
+    currentContexts[context.type] = {
+        context,
+        meta: Object.assign(Object.assign({}, (_a = currentContexts[context.type]) === null || _a === void 0 ? void 0 : _a.meta), { timestamp: Date.now() }),
+    };
+};
+const getInitialState = () => {
+    return {
+        pendingInteropRegistrationData: [],
+        pendingOpenActionIds: {},
+        config: {
+            serverUUID: `interopService.${Date.now()}_${Math.random()}`,
+            registeredUIResolver: null,
+        },
+        clients: {},
+        selectConnectChannels: {},
+        channelMeta: {},
+        lastChannelState: {},
+        lastChannelStateByType: {},
+        apps: {
+            definitions: {},
+            intentResolutionInProgress: false,
+            intentResolutionCurrentActionId: null,
+        },
+        intents: {},
+        contextTypes: {},
+        queue: {},
+        loopDetectionMap: {},
+        addIntentListenerMaxInitializationTimeout: 15000,
+    };
+};
+export const openApp = async ({ actionId, appId, pendingMessage, originatingAppId, originatingAppWindow, appDefinitions, }) => {
+    let error;
+    let windowName = undefined;
+    // Don't try to open an app that isn't known to the interopService. Cleaner but also because spawn results are inconsistent in picking up spawn errors.
+    if (appDefinitions[appId]) {
+        // set windowInterop.parent so auto-associate will work correctly for FDC3.
+        const { error: launcherError, response } = await LauncherClient.spawn(appId, {
+            addToWorkspace: true,
+            windowInterop: { parent: { windowName: originatingAppWindow, componentType: originatingAppId } },
+        });
+        if (response) {
+            const wi = response === null || response === void 0 ? void 0 : response.windowIdentifier;
+            windowName = wi === null || wi === void 0 ? void 0 : wi.windowName;
+            // something went wrong if the assigned window name has "undefined-" in it (this case doesn't result in a spawn error code being returned)
+            error = (launcherError !== null && launcherError !== void 0 ? launcherError : (windowName && windowName.includes("undefined-"))) ? `app ${appId} is undefined` : null;
+            Logger.system.debug("Interop.resolver.openApp", {
+                appId,
+                windowName,
+                pendingMessage,
+                response,
+            });
+        }
+        else {
+            error = "No response from LauncherClient.spawn()";
+        }
+    }
+    else {
+        error = `Application ${appId} not found in AppD configuration`;
+    }
+    return {
+        actionId,
+        error,
+        windowName,
+        pendingMessage,
+    };
+};
+// handles app resolution for raising an intent
+export const resolveIntentApps = async (actionId, resolutionList, pendingMessage, originatingAppName, originatingAppId, originatingAppWindow) => {
+    const intentTargetList = {
+        resolutionList,
+        originatingAppName,
+        originatingAppId,
+        originatingAppWindow,
+    };
+    Logger.system.debug("Sending message to INTENT_RESOLVER_CHANNEL", INTENT_RESOLVER_CHANNEL, intentTargetList);
+    const { err, response } = await RouterClient.query(INTENT_RESOLVER_CHANNEL, intentTargetList);
+    if (err)
+        Logger.system.error("resolveIntentApps", err.toString());
+    const resolverResolution = response === null || response === void 0 ? void 0 : response.data;
+    Logger.system.debug("Interop.resolver.resolveIntentApps query response", {
+        intentTargetList,
+        resolverResolution,
+    });
+    return {
+        actionId,
+        resolverResolution,
+        pendingMessage,
+    };
+};
+/**
+ * Sends an intent to the FDC3 Resolver UI.
+ */
+const sendIntentToAppResolver = ({ state, cmd, actionId, fsa, resolutionList, originatingAppWindow, }) => {
+    var _a, _b, _c, _d;
+    // We will send a new intent to the UI, whether it's busy or not.
+    // If it is busy, cancel whatever it was busy with.
+    if (state.resolver.apps.intentResolutionInProgress) {
+        // Warning that this is what we're doing
+        Logger.warn("An intent has been raised while the previous intent remains unresolved. The previously raised intent will be cancelled.");
+        // Resolve previous action with ResolverUnavailable (same thing that gets fired when a raised intent is cancelled)
+        const raiseIntentResult = {
+            type: "raiseIntent",
+            error: ResolveError.ResolverUnavailable,
+        };
+        setActionResult(state.resolver.apps.intentResolutionCurrentActionId, raiseIntentResult);
+    }
+    state.resolver.apps.intentResolutionInProgress = true;
+    state.resolver.apps.intentResolutionCurrentActionId = actionId;
+    // Tell the UI resolver the name of the originating app, and if we don't know the name just use the uuid
+    const originatingAppName = (_b = (_a = state.resolver.clients[fsa.meta.uuid]) === null || _a === void 0 ? void 0 : _a.appName) !== null && _b !== void 0 ? _b : fsa.meta.uuid;
+    const originatingAppId = (_d = (_c = state.resolver.clients[fsa.meta.uuid]) === null || _c === void 0 ? void 0 : _c.appId) !== null && _d !== void 0 ? _d : originatingAppName;
+    cmd === null || cmd === void 0 ? void 0 : cmd.run(resolveIntentApps, {
+        args: [actionId, unImmer(resolutionList), fsa, originatingAppName, originatingAppId, originatingAppWindow],
+        successActionCreator: actions.handleUIResolutionResponse,
+    });
+};
+/**
+ * Sends an intent to a running app by looping the fsa to broadcast
+ */
+const sendIntentToRunningApp = ({ app, cmd, fsa, }) => {
+    const { uuid } = app;
+    const interopBroadcast = Object.assign(Object.assign({}, fsa), { meta: Object.assign(Object.assign({}, fsa.meta), { to: uuid }) });
+    cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.broadcast(interopBroadcast));
+};
+/**
+ * Opens an app as a result of a RaiseIntent. The intent is forwarded
+ * to `openApp` which will then queue it until a listener is registered
+ */
+const openAppForIntent = ({ actionId, fsa, cmd, state, appId, originatingAppId, originatingAppWindow, }) => {
+    Logger.system.debug("Interop.resolver.raiseIntent opening app", {
+        appId,
+        fsa,
+    });
+    cmd === null || cmd === void 0 ? void 0 : cmd.run(openApp, {
+        args: [
+            {
+                actionId,
+                appId,
+                pendingMessage: fsa,
+                originatingAppId,
+                originatingAppWindow,
+                appDefinitions: unImmer(state.resolver.apps.definitions),
+            },
+        ],
+        successActionCreator: actions.openedApp,
+    });
+};
+/**
+ * Filter any stale messages from queue and respond to any corresponding pending actions.
+ * This is an indirect method to recognize an apps isn't following expected behavior as defined in appD.
+ */
+export const filterAndResolveStaleMessages = ({ state }, cmd) => {
+    // Any message that has not been delivered within ERROR_TIME is a stale message that will be dropped
+    const ERROR_TIME = 60 * 1000;
+    // ERROR_TIME often takes too long for the typical developer feedback, so put out a warning message earlier.
+    const WARNING_TIME = 10 * 1000;
+    Object.keys(state.resolver.queue).forEach((key) => {
+        const queue = state.resolver.queue[key];
+        Logger.system.debug(`Interop.resolver.filterAndResolveStaleMessages ${key} queue depth=${queue.length}`, queue);
+        // Filter out and process messages that are ready to be sent (or drop stale messages). It is important to abide by the queue's order, processing from oldest to newest.
+        const newQueue = queue.filter((item) => {
+            const { pendingMessage, timestamp } = item;
+            // Filter the message if the timestamp has expired; might happen for app that doesn't register for pending message;
+            // Large ERROR_TIME value is needed to cover a large workspace load of heavy apps.
+            // We probably need a config value; in mean time a mid-range but sufficiently large timer value is used
+            if (timestamp && Date.now() - timestamp > ERROR_TIME) {
+                Logger.error("Stale interop message discarded since no receiving app. Interop.resolver.filterAndResolveStaleMessages: Message expired because it couldn't be delivered. Likely cause is app behavior doesn't match expected behavior, perhaps due to appD config", item, pendingMessage);
+                const messageTitle = "FDC3 AppD Config Issue";
+                const messageDetails = `Stale interop message discarded since no receiving app. Check the central logger for more information.`;
+                const devModeOnly = true;
+                cmd === null || cmd === void 0 ? void 0 : cmd.run(notifyEndUser, {
+                    args: [messageTitle, messageDetails, devModeOnly],
+                });
+                // if the stale message has a pending action, then respond to the action with an error
+                const { pendingActionId } = pendingMessage.meta;
+                if (pendingActionId) {
+                    const actionResult = pendingActionId.type === "raiseIntent"
+                        ? {
+                            type: "raiseIntent",
+                            error: ResolveError.ResolverTimeout,
+                        }
+                        : {
+                            type: "open",
+                            error: OpenError.AppTimeout,
+                        };
+                    setActionResult(pendingActionId, actionResult);
+                }
+                return false;
+            }
+            else if (timestamp && Date.now() - timestamp > WARNING_TIME) {
+                Logger.warn("Interop.resolver.filterAndResolveStaleMessages: Message has been in the queue a long time.  Possible cause is app behavior doesn't match appD config (e.g. app doesn't handle intent that appD indicates is handled", item);
+            }
+            // otherwise the message is not stale so keep it
+            return true;
+        });
+        newQueue.length ? (state.resolver.queue[key] = newQueue) : delete state.resolver.queue[key];
+    });
+};
+/**
+ * Logs an error if an app didn't add listeners for all the intents identified in its AppD definition
+ */
+const verifyListeners = ({ state }, cmd) => {
+    Object.keys(state.resolver.apps.definitions).forEach((appId) => {
+        const appDefinition = state.resolver.apps.definitions[appId];
+        // If the name and appId are the same, then that's our name. Otherwise, we might have multiple instances of
+        // the same name, so we use a compound `Chart:3424343`
+        const friendlyName = getFriendlyName(appDefinition);
+        Logger.system.debug(`Interop.resolver.verifyIntentListeners checking ${friendlyName}`);
+        const initializationComplete = (appDefinition === null || appDefinition === void 0 ? void 0 : appDefinition.firstRegistrationTimestamp) &&
+            Date.now() - appDefinition.firstRegistrationTimestamp > state.resolver.addIntentListenerMaxInitializationTimeout;
+        if (initializationComplete && !(appDefinition === null || appDefinition === void 0 ? void 0 : appDefinition.verified)) {
+            const intents = (appDefinition === null || appDefinition === void 0 ? void 0 : appDefinition.intents) ? Object.values(appDefinition === null || appDefinition === void 0 ? void 0 : appDefinition.intents) : [];
+            // An app is incomplete if it didn't add a listener for at least one of the intents in its AppD entry
+            const missingIntents = intents.flatMap((intent) => (intent.appListenerAdded ? [] : [intent.name]));
+            if (missingIntents.length) {
+                // If incomplete then log an error, but only do it once for the app
+                Logger.system.error(`Interop.resolver.verifyIntentListeners: "${friendlyName}" didn't call addIntentListener() for intents specified in its AppD config. Update AppD config to match functionality of app.`, "MISSING INTENTS:", missingIntents, "EXPECTED INTENTS:", appDefinition.intents);
+                const messageTitle = "FDC3 AppD Config Issue";
+                const messageDetails = `"${friendlyName}" didn't call addIntentListener() for intents "${missingIntents}" specified in its AppD config. Check the central logger for more information.`;
+                const devModeOnly = true; // This const sole purpose is to improve readability when invoking the notifyEndUser method bellow.
+                // the true argument is to flag that this a notification to display in dev mode only
+                cmd === null || cmd === void 0 ? void 0 : cmd.run(notifyEndUser, {
+                    args: [messageTitle, messageDetails, devModeOnly],
+                });
+            }
+            // Regardless of whether it registered all intents or not, it's now been verified. With this flag set to true we'll never get another
+            // user notification for that app type again.
+            appDefinition.verified = true;
+        }
+    });
+};
+/**
+ * Sends a heartbeat message to every attached client. Clients can use the receipt/non-receipt of a heartbeat
+ * to assess whether they've lost connectivity to the interop service.
+ */
+const sendHeartbeats = ({ state }, cmd) => {
+    Logger.system.debug(`Interop.resolver.sendHeartbeats`, Object.keys(state.resolver.clients));
+    const heartbeatFSA = {
+        type: "heartbeat",
+        meta: {
+            uuid: "interopService",
+        },
+    };
+    Object.values(state.resolver.clients).forEach((client) => {
+        cmd === null || cmd === void 0 ? void 0 : cmd.run(sendMessageOnRouter, {
+            args: [client.routerChannel, heartbeatFSA],
+        });
+    });
+};
+/**
+ * Filter any messages from queue that are addressed to unregistered clients plus respond to any corresponding pending actions.
+ */
+const filterAndResolveDeadMessages = ({ state }) => {
+    Object.keys(state.resolver.queue).forEach((key) => {
+        const queue = state.resolver.queue[key];
+        Logger.system.debug(`Interop.resolver.filterAndResolveDeadMessages ${key} queue depth=${queue.length}`, queue);
+        const newQueue = queue.filter((item) => {
+            const { pendingMessage } = item;
+            // if message destination is not registered, then it is a dead message
+            if (state.resolver.clients[pendingMessage.meta.uuid] === undefined) {
+                Logger.error("Interop.resolver.filterAndResolveDeadMessages: Destination client is not registered so message dropped.", item, pendingMessage);
+                // if the dead message has a pending action, then respond to the action with an error
+                const { pendingActionId } = pendingMessage.meta;
+                if (pendingActionId) {
+                    const actionResult = pendingActionId.type === "raiseIntent"
+                        ? {
+                            type: "raiseIntent",
+                            error: ResolveError.ResolverTimeout,
+                        }
+                        : {
+                            type: "open",
+                            error: OpenError.AppTimeout,
+                        };
+                    setActionResult(pendingActionId, actionResult);
+                }
+                return false;
+            }
+            // otherwise the message is not dead so keep it
+            return true;
+        });
+        newQueue.length ? (state.resolver.queue[key] = newQueue) : delete state.resolver.queue[key];
+    });
+};
+/**
+ * Returns true if the message matches any of the provided criteria
+ */
+const matchMessage = ({ pendingMessage, type, intent, contextType, channel, }) => {
+    var _a;
+    if (type && pendingMessage.type === type)
+        return true;
+    if (intent && pendingMessage.payload.intent === intent)
+        return true;
+    if (contextType && ((_a = pendingMessage.payload.context) === null || _a === void 0 ? void 0 : _a.type) === contextType)
+        return true;
+    return !!(channel && pendingMessage.meta.channel === channel);
+};
+/**
+ * Releases queued messages. This can be called from three possible places:
+ * 1) subscribeContext - In order to release any pending broadcasts (such as from a prior `open` call, or from a #Workspace initializing broadcast)
+ * 2) subscribeIntent - Similarly, in order to release any pending intents from a prior call to `raiseIntent`
+ * 3) register - When an app client registers (and thus selectConnect rules can be processed correctly)
+ *
+ * This manages a race condition. subscribeContext/subscribeIntent can occur both before or after register completes.
+ * (a) When they occur before, then the app won't yet be ready, so the items remain queued but the "subscriberIsReady" flag is flipped to true.
+ *     Then when register calls releaseQueuedMessages again, all of the items with subscriberIsReady will be released.
+ *
+ * (b) When they occur after, the app will already be ready, so the items will immediately be broadcast
+ */
+export const releaseQueuedMessages = ({ state, uuid, channel, cmd, type, intent, contextType, }) => {
+    const { windowName, readiness } = state.resolver.clients[uuid];
+    const key = state.resolver.queue[uuid] ? uuid : windowName;
+    const queue = state.resolver.queue[key];
+    if (!queue)
+        return;
+    Logger.system.debug(`Interop.resolver.releaseQueuedMessages ${windowName} depth=${queue.length}`, {
+        queue,
+        state: state.resolver,
+        uuid,
+        channel,
+        cmd,
+        type,
+        intent,
+        contextType,
+    });
+    // Filter out and process messages that are ready to be sent. It is important to abide by the queue's order, processing from oldest to newest.
+    const newQueue = queue.filter((item) => {
+        const { pendingMessage } = item;
+        /**
+         * Tricky logic here. If "type" is set then the call was from subscribeContext or subscribeIntent. In this case
+         * if the app isn't yet ready then just set the subscriberIsReady flag to true
+         *
+         * But if "type" isn't set, then the call was from register. The app is now ready, so release this
+         * item only if a prior call to subscribeContext or subscribeIntent has flipped the subscriberIsReady flag to true.
+         */
+        if (type && readiness !== "ready") {
+            item.subscriberIsReady = true;
+            return true;
+        }
+        else if (!type && !item.subscriberIsReady) {
+            return true;
+        }
+        // If the message doesn't match any of our criteria for releasing, then keep it in the queue
+        if (!matchMessage({ pendingMessage, type, intent, contextType, channel }))
+            return true;
+        // Make sure the broadcast is only to this specific uuid
+        const directedMessage = Object.assign(Object.assign({}, pendingMessage), { meta: Object.assign(Object.assign({}, pendingMessage.meta), { to: uuid }) });
+        Logger.system.debug(`Interop.resolver.releaseQueuedMessages ${windowName} BROADCAST`, item, directedMessage);
+        // Broadcast it now that we're subscribed
+        cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.broadcast(unImmer(directedMessage)));
+        // and unqueue it
+        return false;
+    });
+    newQueue.length ? (state.resolver.queue[key] = newQueue) : delete state.resolver.queue[key];
+};
+const getDestinationsForContext = ({ clients, sender, senderUuid, channel: toChannel, context, to, autoBroadcast, }) => {
+    const contextType = context.type;
+    const destinationForChannel = (receiver, channel, isSubscribed, isSubscribedToWildcard) => {
+        var _a, _b, _c, _d;
+        const { routerChannel, uuid } = receiver;
+        const subscribedOnThisChannel = !!((_b = (_a = receiver.subscriptions.channels[channel]) === null || _a === void 0 ? void 0 : _a.contexts[contextType]) === null || _b === void 0 ? void 0 : _b.context);
+        const subscribedToWildCardOnThisChannel = !!((_d = (_c = receiver.subscriptions.channels[channel]) === null || _c === void 0 ? void 0 : _c.contexts["*"]) === null || _d === void 0 ? void 0 : _d.context);
+        const type = "client";
+        // Is receiver listening on the specified channel?
+        if (receiver.subscriptions.channels[channel]) {
+            if (subscribedOnThisChannel)
+                return [{ type, uuid, channel, contextType, context, routerChannel }];
+            if (subscribedToWildCardOnThisChannel)
+                return [{ type, uuid, channel, contextType: "*", context, routerChannel }];
+        }
+        // Is receiver joined to this channel? (the sender has chosen to broadcast directly on a "system channel" using the channel API)
+        // In this case, don't include the "channel" in the destination message
+        const destination = (isSubscribed && [{ type, uuid, contextType, context, routerChannel }]) ||
+            (isSubscribedToWildcard && [{ type, uuid, contextType: "*", context, routerChannel }]) ||
+            [];
+        if (receiver.joinedChannels.includes(channel)) {
+            return destination;
+        }
+        // Broadcasts that don't specify a channel are received by listeners on their global channel
+        return [];
+    };
+    const destinationFor = (receiver, isSubscribed, isSubscribedToWildcard) => {
+        var _a, _b, _c, _d, _e;
+        const { routerChannel, uuid } = receiver;
+        const type = "client";
+        // The destination is the context listener, and if not then the wild card listener, and if not then nothing
+        const destination = (isSubscribed && [{ type, uuid, contextType, context, routerChannel }]) ||
+            (isSubscribedToWildcard && [{ type, uuid, contextType: "*", context, routerChannel }]) ||
+            [];
+        // Directed messages should only go to that specific app
+        if (to)
+            return destination;
+        // Is the receiver joined to any of the same channels as the sender?
+        if (sender && sender.joinedChannels.some((c) => receiver.joinedChannels.includes(c)))
+            return destination;
+        // Are neither sender nor receiver using the linker, and neither are joined to channels (independently of using the linker)
+        if (!((_b = (_a = receiver.config) === null || _a === void 0 ? void 0 : _a.interop) === null || _b === void 0 ? void 0 : _b.useLinker) &&
+            !((_d = (_c = sender === null || sender === void 0 ? void 0 : sender.config) === null || _c === void 0 ? void 0 : _c.interop) === null || _d === void 0 ? void 0 : _d.useLinker) &&
+            !((_e = sender === null || sender === void 0 ? void 0 : sender.joinedChannels) === null || _e === void 0 ? void 0 : _e.length) &&
+            !receiver.joinedChannels.length) {
+            return destination;
+        }
+        return [];
+    };
+    const destinations = Object.values(clients).flatMap((receiver) => {
+        var _a, _b;
+        // Filter any clients not in our store
+        if (!receiver)
+            return [];
+        const { routerChannel, uuid } = receiver;
+        // Don't send messages to ourselves, but allow if autoBroadcast (where senderUuid must be set to destination uuid for authentication)
+        if (uuid === senderUuid && !autoBroadcast)
+            return [];
+        // If the message is directed to a specific recipient then ignore all other uuids
+        if (to && uuid !== to)
+            return [];
+        // The set of all possible applicable subscriptions
+        const isSubscribed = !!((_a = receiver.subscriptions.globals.contexts[contextType]) === null || _a === void 0 ? void 0 : _a.context);
+        const isSubscribedToWildcard = !!((_b = receiver.subscriptions.globals.contexts["*"]) === null || _b === void 0 ? void 0 : _b.context);
+        const type = "client";
+        // Broadcasts on a specific "app channel" are only received by listeners on that specific channel
+        if (toChannel)
+            return destinationForChannel(receiver, toChannel, isSubscribed, isSubscribedToWildcard);
+        // Derive the destination - e.g. from joined system channels or directed message ("to")
+        const destination = destinationFor(receiver, isSubscribed, isSubscribedToWildcard);
+        if (destination.length)
+            return destination;
+        // broadcast messages originating internally do not have a sender, so skip next check if sender isn't defined
+        if (!sender)
+            return [];
+        // Is the receiver listening for this context type *only* on a specified system channel that the sender is joined to?
+        // i.e. did the receiver call channel.addContextLister() on a system channel?
+        const channelSends = sender.joinedChannels.flatMap((joinedChannel) => {
+            var _a, _b, _c, _d;
+            const localSubscription = (_b = (_a = receiver.subscriptions.channels[joinedChannel]) === null || _a === void 0 ? void 0 : _a.contexts[contextType]) === null || _b === void 0 ? void 0 : _b.context;
+            const localAnySubscription = (_d = (_c = receiver.subscriptions.channels[joinedChannel]) === null || _c === void 0 ? void 0 : _c.contexts["*"]) === null || _d === void 0 ? void 0 : _d.context;
+            if (localSubscription)
+                return [{ type, uuid, channel: joinedChannel, contextType, context, routerChannel }];
+            if (localAnySubscription)
+                return [{ type, uuid, channel: joinedChannel, contextType: "*", context, routerChannel }];
+            return [];
+        });
+        if (channelSends.length)
+            return channelSends;
+        // Any remaining clients aren't listening on the correct channel or contextType
+        return [];
+    });
+    return destinations;
+};
+const getDestinationsForIntent = ({ clients, to, context, intent, }) => {
+    const contextType = context === null || context === void 0 ? void 0 : context.type;
+    const receiver = clients[to];
+    // flatMap is used to add or remove items from an array: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap#for_adding_and_removing_items_during_a_map
+    const destinations = Object.values(clients).flatMap((destination) => {
+        // Filter any clients not in our store
+        if (!destination)
+            return [];
+        const { routerChannel, uuid } = destination;
+        // The set of all possible applicable subscriptions
+        const globalSubscription = receiver.subscriptions.globals.intents[intent];
+        const type = "client";
+        if (uuid == receiver.uuid) {
+            // When we find our receiver (if it's subscribed which it should be) then add it as a destination for the intent
+            if (globalSubscription)
+                return [{ type, uuid, intent, contextType, context, routerChannel }];
+        }
+        else if (context &&
+            globalSubscription &&
+            (receiver === null || receiver === void 0 ? void 0 : receiver.joinedChannels.some((c) => destination.joinedChannels.includes(c)))) {
+            // But if any destination is linked to the receiver (i.e. joined to any of the same channels) then also send that destination a context update (no intent!)
+            return [{ type, uuid, contextType, context, routerChannel }];
+        }
+        // Any remaining clients aren't listening on the correct channel or intent
+        return [];
+    });
+    return destinations;
+};
+/**
+ * Returns timestamp when JWT was created (uses JWT header data, which is also included in the signed data).
+ */
+const getJwtCreationTime = (jwt) => {
+    try {
+        const jwtData = JSON.parse(atob(jwt.split(".")[1]));
+        return jwtData.iat * 1000; // JWT uses seconds but milliseconds should be returned for timestamp compatibility
+    }
+    catch (e) {
+        Logger.system.error(`Interop.resolver.validAuthenticationToken: getJwtCreationTime failed.  Bad JWT ${jwt}.`);
+        return 0; // must ensure expired if bad JWT
+    }
+};
+/**
+ * Returns true if static authorization signature has expired. This timestamp prevents static authentication tokens from being reused.
+ */
+const SIGNATURE_TTL = 30000; // static auth uses a TTL check distinct from dynamic auth
+const expiredStaticAuthSignature = (authenticationToken) => {
+    // Typically the timestamp field is already set, but for a JTW the timestamp field must be set here to when the JWT was created.
+    // Note for static auth, the timestamp field is in the signed data, but for JWT the iot field can be reliably used.
+    if (authenticationToken.signatureStringType === "static-jwt") {
+        authenticationToken.timestamp = getJwtCreationTime(authenticationToken.signatureString);
+    }
+    const expired = authenticationToken.timestamp != undefined && Date.now() - authenticationToken.timestamp > SIGNATURE_TTL;
+    return expired;
+};
+/**
+ * Returns matching InteropRegistrationData based on windowName
+ * @param windowName
+ * @param pendingInteropRegistrationData
+ * @returns matching object
+ */
+const getMatchingInteropRegistrationData = (windowName, pendingInteropRegistrationData) => {
+    const matchingRegistrationData = pendingInteropRegistrationData.find((registrationData) => windowName === registrationData.name);
+    Logger.system.debug(`Interop.resolver.getMatchingInteropRegistrationData result for ${windowName}`, {
+        windowName,
+        matchingRegistrationData,
+    });
+    return matchingRegistrationData;
+};
+const removeAppInteropRegistrationData = (windowName, pendingInteropRegistrationData) => {
+    let whatWillBeFiltered = pendingInteropRegistrationData.filter((registrationData) => windowName === registrationData.name);
+    let filteredRegistrationData = pendingInteropRegistrationData.filter((registrationData) => windowName !== registrationData.name);
+    Logger.system.debug("forceObjectsToLogger", `Interop.resolver.removeAppInteropRegistrationData for ${windowName}`, {
+        windowName,
+        whatWillBeFiltered,
+        filteredRegistrationData,
+        pendingInteropRegistrationData,
+    });
+    return filteredRegistrationData;
+};
+/**
+ * Returns signiture key (i.e. the public key) needed for static auth.  The key may be in config or referenced by a URL.
+ * @param config
+ * @returns a signature key, or undefined if key couldn't be found
+ */
+const getSignatureKey = async (config) => {
+    let signatureKey;
+    if (config === null || config === void 0 ? void 0 : config.signatureKeyURL) {
+        let { err, getData } = await httpGet(config.signatureKeyURL);
+        if (err) {
+            Logger.system.error(`Interop.resolver.getSignatureKey: the fetch for the signature key failed: ${err}`, {
+                config,
+            });
+        }
+        else {
+            signatureKey = getData;
+        }
+    }
+    else if (config === null || config === void 0 ? void 0 : config.signatureKey) {
+        ({ signatureKey } = config);
+    }
+    Logger.system.debug(`Interop.resolver.getSignatureKey result`, {
+        config,
+        signatureKey,
+    });
+    return signatureKey;
+};
+/**
+ * Returns true if static authentication was successful
+ * @param config
+ * @param authenticationToken
+ * @returns true if authenticated and false otherwise
+ */
+export const validStaticAuthenticationToken = async (config, authenticationToken) => {
+    let authenticated = false;
+    const signatureKey = await getSignatureKey(config);
+    if (signatureKey) {
+        if (!expiredStaticAuthSignature(authenticationToken)) {
+            if (authenticationToken.signatureStringType === "static-jwt") {
+                const { verificationResult } = await authVerifyJWT(signatureKey, authenticationToken.signatureString);
+                authenticated = verificationResult;
+            }
+            else if (authenticationToken.signatureStringType === "static") {
+                const { verificationResult } = await authVerify(signatureKey, authenticationToken.signatureString, { timestamp: authenticationToken.timestamp });
+                authenticated = verificationResult;
+            }
+            else {
+                Logger.system.error(`Interop.resolver.validAuthenticationToken static authenticated failed -- token signatureStringType must be "static" or "static-jwt", but found ${authenticationToken.signatureStringType}`, config, authenticationToken);
+            }
+        }
+        else {
+            Logger.system.error("Interop.resolver.validAuthenticationToken static authenticated failed due to missing or expired authentication timestamp.", config, authenticationToken, Date.now());
+        }
+        if (authenticated) {
+            Logger.system.debug("Interop.resolver.validAuthenticationToken static authenticated successful", config, authenticationToken);
+        }
+        else if (!expiredStaticAuthSignature(authenticationToken)) {
+            Logger.system.error("Interop.resolver.validAuthenticationToken static authenticated failed. Confirm the app's AppD config has the correct `signatureKey` value.", config, authenticationToken);
+        }
+    }
+    else {
+        Logger.system.error("Interop.resolver.validAuthenticationToken static authenticated failed -- `signatureKey` could not be found", config, authenticationToken);
+    }
+    return authenticated;
+};
+// Returns true if an app is autoAssociated with the parent (as specified in the parents's appD).
+const isAutoAssociatedWithParent = (appId, parentAppD) => {
+    var _a, _b, _c, _d;
+    let autoAssociate;
+    let selectedChild = false;
+    const selectConnectProp = (_b = (_a = parentAppD === null || parentAppD === void 0 ? void 0 : parentAppD.manifest) === null || _a === void 0 ? void 0 : _a.interop) === null || _b === void 0 ? void 0 : _b.selectConnect;
+    if (Array.isArray(selectConnectProp)) {
+        const autoAssociateElement = (_c = selectConnectProp === null || selectConnectProp === void 0 ? void 0 : selectConnectProp.find((element) => element.autoAssociate)) !== null && _c !== void 0 ? _c : {};
+        ({ autoAssociate } = autoAssociateElement);
+        if (Array.isArray(autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.selectChildren)) {
+            selectedChild = (_d = autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.selectChildren) === null || _d === void 0 ? void 0 : _d.includes(appId);
+        }
+    }
+    return ((autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.allChildren) || selectedChild || (!(autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.selectChildren) && (autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.usingConnectId)));
+};
+// Returns true if an app auto-associates its children (as specified in the app's appD).
+const isAutoAssociatingChildren = (appD) => {
+    var _a, _b, _c;
+    let autoAssociate;
+    const selectConnectProp = (_b = (_a = appD === null || appD === void 0 ? void 0 : appD.manifest) === null || _a === void 0 ? void 0 : _a.interop) === null || _b === void 0 ? void 0 : _b.selectConnect;
+    if (Array.isArray(selectConnectProp)) {
+        const autoAssociateElement = (_c = selectConnectProp === null || selectConnectProp === void 0 ? void 0 : selectConnectProp.find((element) => element.autoAssociate)) !== null && _c !== void 0 ? _c : {};
+        ({ autoAssociate } = autoAssociateElement);
+    }
+    return (autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.allChildren) || (autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.selectChildren) || (autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.usingConnectId);
+};
+const getAppDSpecifiedConnectId = (appD) => {
+    var _a, _b, _c;
+    let autoAssociate;
+    const selectConnectProp = (_b = (_a = appD === null || appD === void 0 ? void 0 : appD.manifest) === null || _a === void 0 ? void 0 : _a.interop) === null || _b === void 0 ? void 0 : _b.selectConnect;
+    if (Array.isArray(selectConnectProp)) {
+        const autoAssociateElement = (_c = selectConnectProp === null || selectConnectProp === void 0 ? void 0 : selectConnectProp.find((element) => element.autoAssociate)) !== null && _c !== void 0 ? _c : {};
+        ({ autoAssociate } = autoAssociateElement);
+    }
+    return autoAssociate === null || autoAssociate === void 0 ? void 0 : autoAssociate.usingConnectId;
+};
+let connectIdCounter = 0; // counter of new connected ids created since startup (for use in newConnectId)
+// Generate a unique connection Id within Finsemble (just unique within this run -- don't  need a GUID)
+const newConnectId = () => `connectId-${new Date().getTime()}-${connectIdCounter++}`;
+// Maps a launchGroupId to a connect Id. Note: the same connectId must always be returned for a given launcherGroupId
+const deriveConnectIdFromLaunchGroupId = (launchGroupId) => `connectId-${launchGroupId}`;
+// Get the connectId for a launcherGroupId.  If launcherGroup app has connectId defined in appD, then use it; otherwise create a connectId directly from the launcherGroup Id
+const getLauncherGroupConnectId = (parentAppD, launchGroupId) => { var _a; return (_a = getAppDSpecifiedConnectId(parentAppD)) !== null && _a !== void 0 ? _a : deriveConnectIdFromLaunchGroupId(launchGroupId); };
+// Return the parent's connectId, which must be defined in the parent's client data. Keeping connectId in client data support dynamic auto-associations.
+const getParentClientConnectId = (parentWindow, clients) => {
+    const uuids = uuidsFromWindowName({ clients, windowName: parentWindow });
+    interopAssertion("uuid exists for parent window", uuids.length === 1);
+    const parentUuid = uuids[0];
+    const { connectId } = clients[parentUuid];
+    interopAssertion("connectId exists for parent", connectId != undefined);
+    return connectId;
+};
+// return client's connectId if defined
+const getClientConnectId = (parentWindow, clients) => {
+    let connectId;
+    const uuids = uuidsFromWindowName({ clients, windowName: parentWindow });
+    if (uuids.length === 1) {
+        const parentUuid = uuids[0];
+        ({ connectId } = clients[parentUuid]);
+    }
+    return connectId;
+};
+// Returns a windows connectId (which might be null). This is the top-level function for getting a window's connectId.
+const maybeGetWindowConnectId = async (windowName, windowDescriptor, clients, appDefinitions) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    const UnknownApp = "unknown-app";
+    const WorkspaceWindowName = "workspaceService";
+    let resolvedConnectId;
+    const appId = (_b = (_a = windowDescriptor === null || windowDescriptor === void 0 ? void 0 : windowDescriptor.componentType) !== null && _a !== void 0 ? _a : windowDescriptor === null || windowDescriptor === void 0 ? void 0 : windowDescriptor.name) !== null && _b !== void 0 ? _b : UnknownApp;
+    const windowInterop = (_c = windowDescriptor === null || windowDescriptor === void 0 ? void 0 : windowDescriptor.windowInterop) !== null && _c !== void 0 ? _c : {};
+    const appD = appDefinitions[appId];
+    const parentAppD = appDefinitions[(_e = (_d = windowInterop.parent) === null || _d === void 0 ? void 0 : _d.componentType) !== null && _e !== void 0 ? _e : UnknownApp];
+    if (windowInterop.connectId) {
+        // if the window already has a connectId in the window descriptor, then use it
+        resolvedConnectId = windowInterop.connectId;
+    }
+    else if (isAutoAssociatedWithParent(appId, parentAppD)) {
+        // if current window is auto-associated with parent then use parent's connectId
+        if (windowInterop.launchGroupId) {
+            resolvedConnectId =
+                (_h = getClientConnectId((_g = (_f = windowInterop.grandParent) === null || _f === void 0 ? void 0 : _f.windowName) !== null && _g !== void 0 ? _g : "undefined", clients)) !== null && _h !== void 0 ? _h : getLauncherGroupConnectId(parentAppD, (_j = windowInterop.launchGroupId) !== null && _j !== void 0 ? _j : "undefined");
+        }
+        else {
+            resolvedConnectId = await getParentClientConnectId((_l = (_k = windowInterop.parent) === null || _k === void 0 ? void 0 : _k.windowName) !== null && _l !== void 0 ? _l : "undefined", clients);
+        }
+        interopAssertion("connectId found for parent", resolvedConnectId != null);
+        // else if this window is auto-associating children then assigned a connect Id to it for future use with spawned children
+    }
+    else if (isAutoAssociatingChildren(appD)) {
+        resolvedConnectId = (_o = (_m = getAppDSpecifiedConnectId(appD)) !== null && _m !== void 0 ? _m : getClientConnectId(windowName, clients)) !== null && _o !== void 0 ? _o : newConnectId();
+    }
+    const spawnedFromWorkspace = ((_p = windowInterop === null || windowInterop === void 0 ? void 0 : windowInterop.parent) === null || _p === void 0 ? void 0 : _p.windowName) === WorkspaceWindowName;
+    Logger.debug("forceObjectsToLogger", "maybeGetWindowConnectId", {
+        windowName,
+        windowDescriptor,
+        clients,
+        appD,
+        appId,
+        parentAppD,
+        windowInterop,
+        spawnedFromWorkspace,
+        resolvedConnectId,
+    });
+    return { connectId: resolvedConnectId, spawnedFromWorkspace };
+};
+// Return window name embedded in identifier. Extracting the name like this is dirty but expediant and effective; still the longer term app security solution will likely supercede this
+const extractWindowName = (id) => id.split(".")[1];
+// authentication is successful only when the window name embedded in the token matches the window name embedded in the router origin
+const validDynamicAuthenticationToken = (routerOrigin, token) => token.signatureString === extractWindowName(routerOrigin);
+/*
+ * Authenticates an FDC3 client and returns if successful
+ *
+ * @param appId
+ * @param friendlyName
+ * @param routerOrigin where the request originated from
+ * @returns true if authenticated and false otherwise
+ */
+const authenticateClient = async ({ appId, friendlyName, routerOrigin, authenticationToken, config, }) => {
+    var _a;
+    Logger.system.debug(`Interop.resolver.authenticateClient App=${friendlyName}}.`, {
+        appId,
+        routerOrigin,
+        authenticationToken,
+    });
+    let authenticated = false;
+    if (appId !== ((_a = authenticationToken === null || authenticationToken === void 0 ? void 0 : authenticationToken.meta.appId) !== null && _a !== void 0 ? _a : authenticationToken === null || authenticationToken === void 0 ? void 0 : authenticationToken.meta.name)) {
+        // confirm the app registered with the right appId
+        Logger.system.error(`Interop.resolver.authenticateClient: authentication failed due to appId mismatch in token. App=${friendlyName}}.`, appId, authenticationToken);
+        authenticated = false;
+    }
+    else if (authenticationToken.signatureStringType === "dynamic") {
+        authenticated = validDynamicAuthenticationToken(routerOrigin, authenticationToken);
+    }
+    else if (authenticationToken.signatureStringType === "static" ||
+        authenticationToken.signatureStringType === "static-jwt") {
+        // authenticate and update app name
+        authenticated = await validStaticAuthenticationToken(config, authenticationToken);
+    }
+    else {
+        // since neither dynamic or static, the app will not be authenticated
+        authenticated = false;
+    }
+    if (!authenticated) {
+        Logger.system.error(`Interop.resolver.register: authentication failed for App=${friendlyName}}.`, routerOrigin, authenticationToken);
+    }
+    return authenticated;
+};
+// Contains all the async processing for registering a client
+const processRegistrationRequest = async ({ appId, resolverState, config, uuid, routerOrigin, windowName, authenticationToken, actionId, }) => {
+    var _a;
+    const appDefinition = (_a = resolverState.apps.definitions[appId]) !== null && _a !== void 0 ? _a : {};
+    const friendlyName = getFriendlyName(appDefinition);
+    // get pending data for the given appId plus remove it from the pending list
+    const matchingRegistrationData = getMatchingInteropRegistrationData(windowName, resolverState.pendingInteropRegistrationData);
+    // get connectId to support auto-associate, which drives the linker's auto-join functionality
+    const { connectId, spawnedFromWorkspace } = await maybeGetWindowConnectId(windowName, matchingRegistrationData, resolverState.clients, resolverState.apps.definitions);
+    const authenticated = await authenticateClient({
+        appId,
+        friendlyName,
+        routerOrigin,
+        authenticationToken,
+        config,
+    });
+    // return to completeRegistration reducer
+    return {
+        config,
+        authenticated,
+        appId,
+        windowName,
+        uuid,
+        connectId,
+        spawnedFromWorkspace,
+        actionId,
+    };
+};
+// Time interval for loop detection.
+const LoopDetectionTimeThreshold = 6000;
+// Number of times an outgoing broadcast must occur within LoopDetectionTimeThreshold time before considered a loop
+const LoopDetectionCountThreshold = 4;
+// The interval to wait before cleaning up after a loop is detected (required to filter out in-transit messages)
+const LoopDetectCleanupInterval = 4000;
+/**
+ * Set timestamp for the last broadcast to a specific client -- this is the timestamp used to detect loops
+ *
+ * @param {string} senderUuid the being sent a broadcast message
+ * @param {LoopDetectionMap} loopDetectionMap
+ */
+const loopDetectionSetTimestamp = (senderUuid, loopDetectionMap) => {
+    let loopDetectionRecord = loopDetectionMap[senderUuid] || {
+        timestamp: 0,
+        count: 0,
+        loopNotificationIssued: false,
+    };
+    loopDetectionRecord.timestamp = Date.now();
+    loopDetectionMap[senderUuid] = loopDetectionRecord;
+    Logger.system.debug("Interop.resolver.loopDetectionSetTimestamp", senderUuid, loopDetectionRecord);
+};
+/**
+ * after loop detected can't immediately reset counter because multiple messages that are still in transit could keep the loop going; so pause then reset (so system will return to normal state)
+ *
+ * @param {string} senderUuid the app sending the broadcast message
+ * @param {ReturnType<typeof setTimeout>} oldTimerId the previous timer if there was one; should clear since being superseded
+ * @returns {Promise<DelayResetResults>}
+ */
+const loopDetectionDelayReset = async (senderUuid, oldTimerId) => {
+    let delayPromise = new Promise((resolve) => {
+        if (oldTimerId)
+            clearTimeout(oldTimerId);
+        let newTimerId = setTimeout(() => {
+            resolve({
+                senderUuid,
+                newTimerId,
+            });
+        }, LoopDetectCleanupInterval);
+    });
+    return delayPromise;
+};
+/**
+ * Determines if there is an infinite broadcast loop.
+ *
+ * Detection Algorithm:
+ * 		If a client that is sent a broadcast message "immediately" bounces back with an outgoing broadcast message
+ * 			AND this broadcast+bounce-back consistently happens multiple times (i.e.LoopDetectionCountThreshold) all within a set time frame (i.e. LoopDetectionTimeThreshold)
+ *		THEN there is a broadcast loop (so return true).
+ * Related Details:
+ * 		a) Anytime this function returns true, the broadcast reducer will drop the broadcast message to help break the loop
+ * 		b) If a client broadcasts a message independently, without receiving a message within the LoopDetectionCountThreshold time, then the message is assumed to not be from
+ * 		   a loop and the client's loop-detection counter is cleared (if there is a loop though it will continue and still be caught later).
+ * 		c) After a loop is detected, the detection counter will be maintained for a time interval, LoopDetectCleanupInterval, so messages will continue to be dropped; otherwise messages in transit can
+ *         restart the loop.  Later after LoopDetectCleanupInterval expires for a detected loop, then the detection counter is reset to restore the client back to its normal operating state.
+ *
+ * Note 1: By considering the context type, a simpler algorithm could identify the most common loop case where a client rebroadcasts an incoming context;
+ * 		   however that could result in a false positive if the user performed a UI action that triggered a broadcast while the same context was also broadcast elsewhere.
+ * Note 2: This algorithm's constants are purposefully set slow (e.g. 6 seconds) to avoid a false positive; however, the tradeoff is it might not detect a loop in a heavily congested system with extremely slow message delivery
+ * 		   due to LoopDetectionTimeThreshold being exceeded. This is more of a issue within a heavy production situation though (e.g. large workspace of apps that are all contributing to a
+ * 		   broadcast storm) -- it isn't likely with typical app integration and initial testing.
+ *
+ * @param {string} senderUuid id of client requesting a broadcast
+ * @param {LoopDetectionMap} loopDetectionMap
+ * @returns {boolean} Returns true if loop detected
+ */
+const loopDetectionFound = (senderUuid, loopDetectionMap, cmd) => {
+    let loopDetected = false;
+    let loopDetectionRecord = loopDetectionMap[senderUuid];
+    if (loopDetectionRecord) {
+        const timeSinceMessageSentTo = Date.now() - loopDetectionRecord.timestamp;
+        // if enough time has passed, reset the counter given a loop implies continuous messages within the time interval
+        if (timeSinceMessageSentTo > LoopDetectionTimeThreshold) {
+            loopDetectionRecord.count = 0;
+            // once the count is exceeded within a specific time period then loop detected -- this will cause messages to start being dropped and eventually stop the loop
+        }
+        else if (timeSinceMessageSentTo <= LoopDetectionTimeThreshold &&
+            ++loopDetectionRecord.count >= LoopDetectionCountThreshold) {
+            loopDetected = true;
+            // display one notification per client per loop detection
+            if (!loopDetectionRecord.loopNotificationIssued) {
+                const messageTitle = "FDC3 broadcast loop detected so messages dropped.";
+                const messageDetails = `A broadcast loop was detected in ${senderUuid}. Check the central logger for more information.`;
+                cmd === null || cmd === void 0 ? void 0 : cmd.run(notifyEndUser, {
+                    args: [messageTitle, messageDetails],
+                });
+                loopDetectionRecord.loopNotificationIssued = true;
+            }
+            // wait, then reset the loop detection state for this app to restore normal functionality
+            cmd.run(loopDetectionDelayReset, {
+                args: [senderUuid, loopDetectionRecord.timerId],
+                successActionCreator: actions.resetDetectedLoopState,
+            });
+        }
+        loopDetectionMap[senderUuid] = loopDetectionRecord;
+        Logger.system.debug("Interop.resolver.loopDetectionFound", loopDetected, senderUuid, timeSinceMessageSentTo, loopDetectionRecord.count);
+    }
+    return loopDetected;
+};
+/**
+ * Returns true if the fsa is okay to be processed. This means that it has to be either and intent or context broadcast.
+ * If it's an intent, then it must have a "to" field (which should have been set by RaiseIntent)
+ *
+ * We also check to make sure that a loop isn't being created.
+ */
+const isValidBroadcastMessage = ({ state, fsa, cmd, }) => {
+    const { intent, context } = fsa.payload;
+    const { uuid, to } = fsa.meta;
+    // Disable loopDetection since false positives are too likely.  Might reconsider later so not deleting.
+    // if (loopDetectionFound(uuid, state.resolver.loopDetectionMap, cmd)) {
+    // 	Logger.error(
+    // 		`interopService detected probable broadcast loop for ${fsa.meta.uuid}`,
+    // 		"Context",
+    // 		context,
+    // 		"Intent",
+    // 		intent
+    // 	);
+    // 	// drop the broadcast message since loop detected (i.e. stop the broadcast loop)
+    // 	return false;
+    // }
+    if (!intent && !context) {
+        const error = `interopService resolver broadcast: message received without a "context" or "intent" field. Cannot be routed.`;
+        state.root.testing.error = error;
+        Logger.error(error, fsa);
+        return false;
+    }
+    if (intent && !to) {
+        const error = `interopService resolver broadcast: intent received without a "to" field. Cannot be routed.`;
+        state.root.testing.error = error;
+        Logger.error(error, fsa);
+        return false;
+    }
+    return true;
+};
+/**
+ * Saves the context from a broadcast message in the store. Contexts are saved in two places:
+ * 1) In the client entry (except when the sending app is raising an intent or opening a new app)
+ * 2) In the channel entry (except when this broadcast is the result of an autoBroadcast)
+ */
+const maybeSaveContext = ({ state, fsa }) => {
+    var _a, _b, _c;
+    const { context, intent } = fsa.payload;
+    const contextType = context === null || context === void 0 ? void 0 : context.type;
+    const { setSenderContext, uuid: senderUuid, channel, autoBroadcast } = fsa.meta;
+    const sender = state.resolver.clients[senderUuid];
+    // If the caller doesn't want its context set (e.g. this broadcast came from `open`) or this broadcast came from an intent
+    const dontSetSenderContext = setSenderContext === false || intent;
+    // If we don't have a context then there's nothing to set.
+    if (!context)
+        return;
+    /**
+     * When an app broadcasts a context we set that broadcasting app's own context in our local store (its state) to that value.
+     * If the context is *already* that value (by deep comparison) then the app probably hasn't been written correctly
+     * and is creating a broadcast loop. In this case we short-circuit.
+     *
+     * We call `removeEmpty()` on each side of the deep comparison in order to avoid false negatives due to mismatches
+     * between null, undefined, and missing object members.
+     *
+     * Note that broadcasts that emanate from `open` should have "meta.setSenderContext===false" to avoid setting their own local context
+     */
+    const currentContexts = channel
+        ? (_a = sender === null || sender === void 0 ? void 0 : sender.subscriptions.channels[channel]) === null || _a === void 0 ? void 0 : _a.contexts
+        : sender === null || sender === void 0 ? void 0 : sender.subscriptions.globals.contexts;
+    if (!dontSetSenderContext && contextType && currentContexts) {
+        // don't check for duplicate broadcasts when autoBroadcasting -- autoBroadcasts can look like duplicates
+        if (!autoBroadcast && isDupBroadcast(currentContexts[contextType], context)) {
+            const warning = `Possible broadcast loop detected for app "${sender.appId}" on context type "${contextType}"`;
+            Logger.warn(warning);
+        }
+        // currently saveCurrentContext only needs to be maintained for isDupBroadcast; otherwise we could remove it.
+        saveCurrentContext(currentContexts, context);
+    }
+    // If the message originates from the workspace module, then use desination's joinedChannels instead of senders.
+    // This exception to the rule is a compromise due to the workspace module not being joined to any channels.
+    const whichClient = fsa.meta.uuid === workspaceUuid && fsa.meta.to ? fsa.meta.to : senderUuid;
+    // The destination channel is the one that is specified, otherwise it is all the app's joined channels
+    const destinationChannels = (_c = (channel ? [channel] : (_b = state.resolver.clients[whichClient]) === null || _b === void 0 ? void 0 : _b.joinedChannels)) !== null && _c !== void 0 ? _c : [];
+    // Broadcasts of contexts must be cached per channels (join, getCurrentContext, and addListener will use).
+    // However, don't save autoBroadcast contexts -- this would introduce a potential timing problem.
+    if (!autoBroadcast) {
+        destinationChannels.forEach((oneChannel) => {
+            var _a;
+            // save, given the last context will be rebroadcast when a client joins a channel
+            state.resolver.lastChannelState[oneChannel] = { context, senderUuid };
+            if (context === null || context === void 0 ? void 0 : context.type) {
+                // save by context type per channel to support getCurrentContext
+                let map = (_a = state.resolver.lastChannelStateByType[oneChannel]) !== null && _a !== void 0 ? _a : {};
+                map[context.type] = { context, senderUuid };
+                state.resolver.lastChannelStateByType[oneChannel] = Object.assign(Object.assign({}, state.resolver.lastChannelStateByType[oneChannel]), { [context.type]: { context, senderUuid } });
+            }
+            Logger.system.debug(`Interop.resolver.broadcast lastChannelState set for ${oneChannel}`, context, state.resolver.lastChannelState, state.resolver.lastChannelStateByType);
+        });
+    }
+};
+/**
+ * If a message is directed ("to") but we haven't found any valid destinations
+ * then it most likely is because this broadcast has occurred before the app is ready
+ * to listen (race condition). So we'll queue the message. Later calls to subscribeContext
+ * will be responsible for dequeuing and rebroadcasting that message.
+ */
+const isUnavailableDirectedMessage = ({ state, fsa, destinations, }) => {
+    var _a;
+    const { to, autoBroadcast } = fsa.meta;
+    if (to && !destinations.length) {
+        // However, if the message is from autoBroadcast then don't queue because the message could become stale (replaced by a more recent broadcast context).
+        // Not to worry, the current context will be autoBroadcast again when `subscribeContext` adds this destination's listener.
+        if (!autoBroadcast) {
+            state.resolver.queue[to] = ((_a = state.resolver.queue[to]) !== null && _a !== void 0 ? _a : []).concat([
+                {
+                    pendingMessage: fsa,
+                    timestamp: Date.now(),
+                },
+            ]);
+        }
+        else {
+            Logger.system.debug(`Interop.resolver.broadcast: autoBroadcast dropped for ${to} since it wasn't a valid destination (e.g. no listener added)`);
+        }
+        return true;
+    }
+    return false;
+};
+/**
+ * Update the current context for all of the destination clients (again this is only to help detect broadcast loops)
+ */
+const saveDestinationContexts = ({ state, destinations }) => {
+    destinations.forEach((destination) => {
+        Logger.system.debug("Interop.resolver.broadcast selectConnectDestinations", destinations);
+        if (destination.type === "client" && destination.context) {
+            const { subscriptions } = state.resolver.clients[destination.uuid];
+            if (destination.channel) {
+                saveCurrentContext(subscriptions.channels[destination.channel].contexts, destination.context);
+            }
+            else {
+                saveCurrentContext(subscriptions.globals.contexts, destination.context);
+            }
+        }
+    });
+};
+/**
+ * A broadcast message can result in many individual actions:
+ * 1) Messages to be sent to individual destinations
+ * 2) Dispatches to be run back through redux
+ * 3) Messages to be sent to one or more remote SelectConnect modules (via router)
+ *
+ * This method takes the set of these destinations that has been calculated by the broadcast logic and
+ * breaks them down into three arrays of individual actions.
+ */
+const breakDownDestinations = ({ state, fsa, destinations, }) => {
+    const { autoBroadcast, targetSubscriberId, pendingActionId } = fsa.meta;
+    const messagesToSend = destinations.flatMap((destination) => {
+        if (destination.type === "client") {
+            let message = {
+                uuid: destination.uuid,
+                routerChannel: destination.routerChannel,
+                pendingActionId,
+                targetSubscriberId: autoBroadcast ? targetSubscriberId : undefined,
+            };
+            // Use this iterative method in order to avoid `channel : undefined` from showing up in the raw Router message
+            if (destination.channel)
+                message.channel = destination.channel;
+            if (destination.context)
+                message.context = destination.context;
+            if (destination.intent)
+                message.intent = destination.intent;
+            return [message];
+        }
+        else {
+            return [];
+        }
+    });
+    const dispatchesToSend = destinations.flatMap((destination) => {
+        var _a;
+        if (destination.type === "selectConnect") {
+            const selectConnectChannel = state.resolver.selectConnectChannels[destination.name];
+            if (selectConnectChannel && "dispatchAction" in selectConnectChannel) {
+                return [
+                    {
+                        type: selectConnectChannel.dispatchAction,
+                        payload: {
+                            fsa,
+                            uuid: destination.uuid,
+                            context: destination.context,
+                            contextType: (_a = destination.context) === null || _a === void 0 ? void 0 : _a.type,
+                            intent: destination.intent,
+                        },
+                    },
+                ];
+            }
+        }
+        return [];
+    });
+    const selectConnectChannelMessagesToSend = destinations.flatMap((destination) => {
+        var _a;
+        if (destination.type === "selectConnect") {
+            const selectConnectChannel = state.resolver.selectConnectChannels[destination.name];
+            if (selectConnectChannel && "routerChannel" in selectConnectChannel) {
+                return [
+                    {
+                        routerChannel: selectConnectChannel.routerChannel,
+                        fsa,
+                        uuid: destination.uuid,
+                        context: destination.context,
+                        contextType: (_a = destination.context) === null || _a === void 0 ? void 0 : _a.type,
+                        intent: destination.intent,
+                    },
+                ];
+            }
+        }
+        return [];
+    });
+    return { messagesToSend, dispatchesToSend, selectConnectChannelMessagesToSend };
+};
+export const getClientAppConfig = (appDConfig) => {
+    var _a, _b, _c, _d, _e, _f;
+    const unscrubbedConfig = appDConfig === null || appDConfig === void 0 ? void 0 : appDConfig.manifest;
+    const interopConfig = (_a = unscrubbedConfig === null || unscrubbedConfig === void 0 ? void 0 : unscrubbedConfig.interop) !== null && _a !== void 0 ? _a : {};
+    // Logic to determine whether to show the linker
+    // 1) Is it explicitly turned on or turned off in the "Window Manager" config?
+    const windowManagerShowLinker = (_d = (_c = (_b = unscrubbedConfig === null || unscrubbedConfig === void 0 ? void 0 : unscrubbedConfig.foreign) === null || _b === void 0 ? void 0 : _b.components) === null || _c === void 0 ? void 0 : _c["Window Manager"]) === null || _d === void 0 ? void 0 : _d.showLinker;
+    // 2) Use the above logic unless `useLinker` is explicitly set in the interop config (override)
+    const useLinker = (_e = interopConfig === null || interopConfig === void 0 ? void 0 : interopConfig.useLinker) !== null && _e !== void 0 ? _e : windowManagerShowLinker !== false;
+    const config = Object.assign(Object.assign({}, unscrubbedConfig), { interop: Object.assign(Object.assign({}, interopConfig), { selectConnect: (_f = interopConfig === null || interopConfig === void 0 ? void 0 : interopConfig.selectConnect) !== null && _f !== void 0 ? _f : [], useLinker }) });
+    return config;
+};
+// Utility function used by joinChannel and subscribeChannel to send one auto-broadcast message to a specified client for a specific handler for given channel and context name.
+// If there is nothing to broadcast, then this function is a no-op.
+const autoBroadCastToSpecifiedClient = ({ uuid, globalSubscription, channel, contextType, targetSubscriberId, resolverState, cmd, }) => {
+    var _a, _b, _c;
+    let channelData;
+    // If specific context type was specified, then get the last channel state for that context; otherwise, just get the last channel state (independent of context)
+    if (contextType && contextType != "*") {
+        channelData = (_b = (_a = resolverState === null || resolverState === void 0 ? void 0 : resolverState.lastChannelStateByType[channel]) === null || _a === void 0 ? void 0 : _a[contextType]) !== null && _b !== void 0 ? _b : {};
+    }
+    else {
+        channelData = (_c = resolverState === null || resolverState === void 0 ? void 0 : resolverState.lastChannelState[channel]) !== null && _c !== void 0 ? _c : {};
+    }
+    // If the channel has context state, then broadcast it to the client.
+    // Note the original broadcasting app's uuid is set in the broadcast's "from" field for proper authorization.
+    if ((channelData === null || channelData === void 0 ? void 0 : channelData.context) && (channelData === null || channelData === void 0 ? void 0 : channelData.senderUuid)) {
+        Logger.system.debug(`Interop.resolver.autoBroadCastToSpecifiedClient: Context broadcasted to ${channel} for ${uuid}`);
+        // the targetSubscriberId specifies in the broadcast tells the client which specific listener's handler should be invoked
+        const directedBroadcast = {
+            type: "broadcast",
+            payload: {
+                context: unImmer(channelData.context),
+            },
+            meta: {
+                uuid: channelData.senderUuid,
+                to: uuid,
+                autoBroadcast: true,
+                targetSubscriberId,
+                channel: globalSubscription ? undefined : channel,
+                noSelectConnect: true,
+            },
+        };
+        cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.broadcast(directedBroadcast));
+    }
+};
+// For each channel left, if no more apps in the channel (i.e. the channel is stale) then clear
+// the channel state; to know if last app in channel, all the clients must be searched
+const cleanupStaleChannels = (channelsLeft, resolverState) => {
+    // In special test cases, this functionality is disabled.
+    if (testPoint.state.disableCleanupStaleChannels)
+        return;
+    const setOfAllClients = Object.values(resolverState.clients);
+    // if all apps have left then channel, then clear the channel state.
+    channelsLeft.forEach((channel) => {
+        let channelStillInUse = setOfAllClients.some((clientInSet) => clientInSet.joinedChannels.includes(channel));
+        if (!channelStillInUse) {
+            Logger.system.debug(`Interop.resolver.cleanupStaleChannels: context state for channel ${channel} cleared since all apps left the channel`);
+            delete resolverState.lastChannelState[channel];
+            delete resolverState.lastChannelStateByType[channel];
+        }
+    });
+};
+const getValidatedAppName = (appId, appDefinitions) => {
+    let appName = null;
+    const appList = appsForAppId(appId, appDefinitions);
+    if (appList.length === 1) {
+        appName = appList[0].name;
+    }
+    else if (appList.length === 0) {
+        Logger.system.warn(`getValidatedAppName: No definitions found for appId=${appId} so no name assigned.`, appList);
+    }
+    else if (appList.length > 1) {
+        Logger.system.error(`getValidatedAppName: Multiple app definitions found for appId=${appId} so no name assigned.`, appList);
+    }
+    return appName;
+};
+const addReducerCases = (builder) => {
+    builder
+        // For an fdc3 client to be authenticated, it must register with a token that is contained in pendingInteropRegistrationData, which is added to here.
+        // The window service's spawn function defines these tokens, sending a copy here and another copy to the newly spawned app.
+        .addCase(actions.setInteropRegistrationData, (state, action) => {
+        const fsa = action.payload;
+        const interopRegistrationData = fsa.payload;
+        const { pendingInteropRegistrationData } = state.resolver;
+        pendingInteropRegistrationData.push(interopRegistrationData.windowDescriptor);
+    })
+        .addCase(actions.heartbeat, (state, action) => {
+        const fsa = action.payload;
+        const { uuid } = fsa.meta;
+        let client = state.resolver.clients[uuid];
+        if (client) {
+            client.heartbeatTime = Date.now();
+            Logger.system.debug(`heartbeat received for client ${client.appId} uuid ${uuid}`);
+        }
+        else {
+            Logger.system.warn(`heartbeat received for undefined uuid ${uuid}`);
+        }
+    })
+        .addCase(actions.register, (state, action, cmd) => {
+        var _a;
+        const { actionId } = action.payload;
+        const { fsa } = action.payload;
+        const { clientChannel: routerChannel, windowName, authenticationToken } = fsa.payload;
+        const { uuid, authenticatedTransport, routerOrigin } = fsa.meta;
+        const { clients } = state.resolver;
+        // appId is the key internal identifier for apps; it is also what is authenticated
+        const appId = (_a = authenticationToken === null || authenticationToken === void 0 ? void 0 : authenticationToken.meta.appId) !== null && _a !== void 0 ? _a : "unknown-appid";
+        let appName = getValidatedAppName(appId, state.resolver.apps.definitions);
+        if (!appName) {
+            appName = `unvalidated-name-for-${appId}`;
+            Logger.system.warn(`Could not validate name for ${appId} so using ${appName}, which might affect SelectConnect rules.`);
+        }
+        const config = getClientAppConfig(state.resolver.apps.definitions[appId]);
+        // Initialize a client entry and add to our state
+        state.resolver.clients = Object.assign(Object.assign({}, clients), { [uuid]: {
+                heartbeatTime: 0,
+                readiness: "initializing",
+                authenticated: false,
+                authenticatedTransport: authenticatedTransport !== null && authenticatedTransport !== void 0 ? authenticatedTransport : {},
+                uuid,
+                windowName,
+                appName,
+                appId,
+                routerChannel,
+                config,
+                channels: [],
+                joinedChannels: [],
+                subscriptions: {
+                    globals: {
+                        contexts: {},
+                        intents: {},
+                    },
+                    channels: {},
+                },
+            } });
+        cmd === null || cmd === void 0 ? void 0 : cmd.run(processRegistrationRequest, {
+            args: [
+                {
+                    appId,
+                    resolverState: unImmer(state.resolver),
+                    config,
+                    uuid,
+                    routerOrigin: routerOrigin !== null && routerOrigin !== void 0 ? routerOrigin : "unknown-router-origin",
+                    windowName,
+                    authenticationToken: unImmer(authenticationToken),
+                    actionId,
+                },
+            ],
+            successActionCreator: actions.completeRegistration,
+        });
+    })
+        .addCase(actions.completeRegistration, (state, action, cmd) => {
+        var _a, _b, _c;
+        const fsa = action.payload;
+        const { config, authenticated, appId, windowName, uuid, connectId, spawnedFromWorkspace, actionId } = fsa;
+        const appDefinition = (_a = state.resolver.apps.definitions[appId]) !== null && _a !== void 0 ? _a : {};
+        const friendlyName = (_b = getFriendlyName(appDefinition)) !== null && _b !== void 0 ? _b : appId;
+        Logger.system.log(`Interop.resolver.completeRegistration for ${friendlyName}.`, action, appDefinition);
+        if (authenticated) {
+            Logger.system.log(`Authentication successful for ${friendlyName}.`);
+        }
+        else {
+            Logger.system.error(`Authentication failed for ${friendlyName}. Check central logger for additional information.`);
+        }
+        // if client has a connectId then save it
+        state.resolver.clients[uuid].connectId = connectId;
+        // update client readiness and authentication result
+        state.resolver.clients[uuid].authenticated = authenticated;
+        state.resolver.clients[uuid].readiness = "ready";
+        // if pendingOpenActionIds has an actionId, then this is the appropriate place to respond to the request that opened this client
+        if (state.resolver.pendingOpenActionIds[windowName]) {
+            // respond to the app that made the open request; this is only for when the open request didn't contain an initial context (otherwise respond when context listener is subscribed to))
+            Logger.system.debug(`Interop.resolver.completeRegistration setting open result for ${windowName}.`);
+            setActionResult(state.resolver.pendingOpenActionIds[windowName], { type: "open" });
+            delete state.resolver.pendingOpenActionIds[windowName];
+        }
+        // signal other modules that new client registered
+        if (!state.resolver.apps.definitions[appId]) {
+            let errorMessage = `Interop.resolver.completeRegistration NOTE: "${friendlyName}" registered without an appD entry in config (e.g. $configRoot/application/appd.json). For full functionality every app must have a corresponding appD entry.`;
+            Logger.system.log(errorMessage);
+            // add a basic appD entry so the client can function as much as possible -- an appD entry is expected elsewhere in the code
+            state.resolver.apps.definitions[appId] = {
+                appId,
+                name: appId,
+                manifest: {
+                    interop: {
+                        useLinker: true,
+                    },
+                },
+            };
+        }
+        // save the time of the first registration to determine when initialization should be complete (see cleanupAndVerify)
+        if (!((_c = state.resolver.apps.definitions[appId]) === null || _c === void 0 ? void 0 : _c.firstRegistrationTimestamp)) {
+            state.resolver.apps.definitions[appId].firstRegistrationTimestamp = Date.now();
+        }
+        const clientAdded = {
+            appId,
+            config,
+            uuid,
+            windowName,
+            connectId,
+            spawnedFromWorkspace,
+        };
+        // this clientAdded action is defined in the linker
+        cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.clientAdded(unImmer(clientAdded)));
+        releaseQueuedMessages({ state, uuid, cmd });
+        setActionResult(actionId, { type: "register" });
+        testPoint.triggerSnapshot("testPointInteropServiceClientAdded", unImmer(state));
+        testPoint.triggerSnapshot("Fdc3RegistrationComplete", {
+            client: unImmer(state.resolver.clients[uuid]),
+        });
+    })
+        .addCase(actions.cleanupAndVerify, (state, action, cmd) => {
+        // Send heartbeats to all attached clients
+        sendHeartbeats({ state }, cmd);
+        // Look through all the client queues to handle any stale message
+        filterAndResolveStaleMessages({ state }, cmd);
+        // Verifies that all newly registered apps' intent listeners includes all of intents in their AppD definitions
+        verifyListeners({ state }, cmd);
+    })
+        .addCase(actions.unregister, (state, action, cmd) => {
+        var _a;
+        const fsa = action.payload;
+        const { uuid } = fsa.meta;
+        const { windowName } = state.resolver.clients[uuid];
+        const channelsToLeaveFrom = (_a = state.resolver.clients[uuid].joinedChannels) !== null && _a !== void 0 ? _a : [];
+        delete state.resolver.clients[uuid];
+        cleanupStaleChannels(channelsToLeaveFrom, state.resolver);
+        // Having dead messages in the queue would be rare, but not impossible. The most common scenario might be an app that never initializes correctly.
+        filterAndResolveDeadMessages({ state });
+        // for now there we can assume its okay to cleanup all the registration data for the corresponding windowName, but might not be true in future
+        state.resolver.pendingInteropRegistrationData = removeAppInteropRegistrationData(windowName, state.resolver.pendingInteropRegistrationData);
+        // If the window that just closed was the Resolver UI, then we need to unregister the Resolver from the uiResolverListener
+        if (uuid === state.resolver.config.registeredUIResolver) {
+            state.resolver.config.registeredUIResolver = null;
+            // also clear "in-progress" flag in case UIResolver closed in the middle of resolving; this prevents progress flag from locking up resolution
+            state.resolver.apps.intentResolutionInProgress = false;
+            state.resolver.apps.intentResolutionCurrentActionId = null;
+        }
+        cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.clientRemoved({
+            uuid,
+            windowName,
+        }));
+        testPoint.triggerSnapshot("testPointInteropServiceClientRemoved", unImmer(state));
+    })
+        /**
+         * This action will accept either InteropBroadcast or InteropBroadcastInternal.
+         * InteropBroadcast is what is received from external desktop agent clients.
+         * InteropBroadcastInternal - is used by internal functions that use broadcast. See the type definition
+         * for more details.
+         */
+        .addCase(actions.broadcast, (state, action, cmd) => {
+        const fsa = action.payload;
+        const { context, intent } = fsa.payload;
+        const { channel, uuid: senderUuid, to, noSelectConnect, autoBroadcast } = fsa.meta;
+        const sender = state.resolver.clients[senderUuid];
+        // For testing and debugging, clear out any previous triggered rules
+        state.root.testing = Object.assign(Object.assign({}, state.root.testing), { triggeredRules: [], destinationsBeforeSelectConnect: [], messagesToSend: [], dispatchesToSend: [], selectConnectChannelMessagesToSend: [], error: "" });
+        // Checks to make sure the message has a valid set of data, and is not a broadcast loop
+        if (!isValidBroadcastMessage({ state, fsa, cmd }))
+            return;
+        // Saves this broadcasted context in the store (in most cases)
+        maybeSaveContext({ state, fsa });
+        /**
+         * When transmitting back to a client due to a joined channel, we actually want the channel id to be null
+         * instead of the relevant joined channel. This is because the client code expects the response on addContextListener() rather than channel.addContextListener()
+         *
+         * Note: "to" will always be set for an intent. "context" will always be set otherwise - but Typescript doesn't know this so we have an extra check for TS's benefit
+         */
+        /* eslint-disable no-nested-ternary */
+        const destinations = intent
+            ? to
+                ? getDestinationsForIntent({
+                    clients: state.resolver.clients,
+                    to,
+                    intent,
+                    context,
+                })
+                : []
+            : context
+                ? getDestinationsForContext({
+                    clients: state.resolver.clients,
+                    sender,
+                    channel,
+                    context,
+                    senderUuid,
+                    to,
+                    autoBroadcast,
+                })
+                : [];
+        state.root.testing.destinationsBeforeSelectConnect = destinations;
+        // If the message is directed ("to") but not destination is available then return
+        // this function will queue if necessary
+        if (isUnavailableDirectedMessage({ state, fsa, destinations }))
+            return;
+        // Run through the selectConnect rules, except for a directed message ("to") which should never be re-routed because it could cause infinite loops
+        // SelectConnect may alter, add or remove destinations
+        const selectConnectDestinations = noSelectConnect
+            ? destinations
+            : (() => {
+                const [newDestinations, triggeredRules] = selectConnect(state, fsa, destinations);
+                state.root.testing.triggeredRules = triggeredRules;
+                return newDestinations;
+            })();
+        // Set's the current context for each destination in the redux store to be what we're just about to send it
+        saveDestinationContexts({ state, destinations: selectConnectDestinations });
+        // Get arrays of each type of action to be looper into other redux actions
+        const { messagesToSend, dispatchesToSend, selectConnectChannelMessagesToSend } = breakDownDestinations({
+            state,
+            fsa,
+            destinations: selectConnectDestinations,
+        });
+        Logger.system.debug("Interop.resolver.broadcast messagesToSend", messagesToSend);
+        Logger.system.debug("Interop.resolver.broadcast dispatchesToSend", dispatchesToSend);
+        Logger.system.debug("Interop.resolver.broadcast selectConnectChannelMessagesToSend", selectConnectChannelMessagesToSend);
+        // Use these store locations for testing and live debugging
+        state.root.testing.messagesToSend = messagesToSend;
+        state.root.testing.dispatchesToSend = dispatchesToSend;
+        state.root.testing.selectConnectChannelMessagesToSend = selectConnectChannelMessagesToSend;
+        if (messagesToSend.length)
+            cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.sendMessageToDestinations(messagesToSend));
+        if (selectConnectChannelMessagesToSend.length)
+            cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.sendSelectConnectMessagesToDestinations(selectConnectChannelMessagesToSend));
+        dispatchesToSend.forEach((dispatchMessage) => {
+            cmd === null || cmd === void 0 ? void 0 : cmd.action(dispatchMessage);
+        });
+    })
+        .addCase(actions.sendMessageToDestinations, (state, action, cmd) => {
+        const messagesToSend = action.payload;
+        messagesToSend.forEach((outgoing) => {
+            var _a, _b, _c, _d, _e;
+            const meta = outgoing.channel
+                ? {
+                    uuid: state.resolver.config.serverUUID,
+                    targetSubscriberId: outgoing.targetSubscriberId,
+                    channel: outgoing.channel,
+                }
+                : {
+                    uuid: state.resolver.config.serverUUID,
+                    targetSubscriberId: outgoing.targetSubscriberId,
+                };
+            let message;
+            if (outgoing.intent) {
+                message = {
+                    type: "intent",
+                    payload: {
+                        intent: outgoing.intent,
+                        context: outgoing.context,
+                    },
+                    meta,
+                };
+            }
+            else if (outgoing.context) {
+                message = {
+                    type: "broadcast",
+                    payload: {
+                        context: outgoing.context,
+                    },
+                    meta,
+                };
+            }
+            // getCurrentContext() with no parameters (no context type) falls back to `mostRecentContext` being set
+            if (outgoing.context)
+                state.resolver.clients[outgoing.uuid].mostRecentContext = outgoing.context;
+            // If pending action that was waiting on message to be sent to client, then action response can be set now.
+            // When we add support for the client to return intent results, this code will change -- raiseIntent won't be done until result received.
+            if (outgoing.pendingActionId) {
+                const source = (_b = (_a = state.resolver.clients[outgoing.uuid]) === null || _a === void 0 ? void 0 : _a.appId) !== null && _b !== void 0 ? _b : "unknown";
+                const version = (_d = (_c = state.resolver.apps.definitions[source]) === null || _c === void 0 ? void 0 : _c.version) !== null && _d !== void 0 ? _d : "unknown";
+                const actionResult = outgoing.pendingActionId.type === "raiseIntent"
+                    ? {
+                        type: "raiseIntent",
+                        result: {
+                            source,
+                            // @ts-ignore
+                            intent: (_e = outgoing.intent) !== null && _e !== void 0 ? _e : "unknown",
+                            version,
+                        },
+                    }
+                    : {
+                        type: "open",
+                        result: {
+                            source,
+                            version,
+                        },
+                    };
+                Logger.system.debug("Interop.resolver.sendMessageToDestinations pendingAction set", outgoing.pendingActionId, actionResult);
+                // Although this message won't actually be transmitted until the sendMessageOnRouter cmd below executes in the next redux loop,
+                // it is virtually done here so invoke setActionResult
+                setActionResult(outgoing.pendingActionId, actionResult);
+            }
+            loopDetectionSetTimestamp(outgoing.uuid, state.resolver.loopDetectionMap);
+            // Send messages out optimistically. We don't wait for a response.
+            cmd === null || cmd === void 0 ? void 0 : cmd.run(sendMessageOnRouter, {
+                args: [outgoing.routerChannel, message],
+            });
+        });
+    })
+        .addCase(actions.sendSelectConnectMessagesToDestinations, (state, action, cmd) => {
+        const messagesToSend = action.payload;
+        messagesToSend.forEach((outgoing) => {
+            cmd === null || cmd === void 0 ? void 0 : cmd.run(sendMessageOnRouter, {
+                args: [outgoing.routerChannel, outgoing],
+            });
+        });
+    })
+        .addCase(actions.subscribeContext, (state, action, cmd) => {
+        var _a;
+        const fsa = action.payload;
+        const { contextType } = fsa.payload;
+        const { channel, uuid, targetSubscriberId } = fsa.meta;
+        let client = state.resolver.clients[uuid];
+        if (!client) {
+            Logger.system.warn(`Interop.resolver.subscribeContext: client ${uuid} unknown so subscribe skipped`);
+            return;
+        }
+        // We use contextType="*" as a wildcard listener
+        const thisContextType = contextType !== null && contextType !== void 0 ? contextType : "*";
+        const thisSubscriberContext = {
+            context: {
+                type: thisContextType,
+            },
+            meta: {
+                timestamp: 0,
+                targetSubscriberId,
+            },
+        };
+        // When new subscriber added, broadcast the latest channel context to the subscribing app.
+        // If the subscriber is for a specific context type, then the last message on the channel for that context type is broadcasted.
+        // Note 1: the broadcast reducer will later filter broadcasts if client isn't authorized.
+        // Note 2: joinChannels will later broadcast if subscriber is added without a channel specified and no joined channels.
+        // Update client subscriptions
+        if (channel) {
+            client.channels = concatNoDups(client.channels, channel);
+            // Add a channel entry for the client if none exists
+            (_a = client.subscriptions.channels[channel]) !== null && _a !== void 0 ? _a : (client.subscriptions.channels[channel] = {
+                contexts: {},
+                intents: {},
+            });
+            // the targetSubscriberId must be maintained here in thisSubscriberContext in case it is needed for autoBroadcast to all listeners when a channel is joined
+            client.subscriptions.channels[channel].contexts[thisContextType] = thisSubscriberContext;
+            // NOTE FDC3 has decided that auto-broadcasts should not occur to app channels, only user channels. Therefore autoBroadCastToSpecifiedClient is not invoked here.
+        }
+        else {
+            client.subscriptions.globals.contexts[thisContextType] = thisSubscriberContext;
+            // For global subscribe: For all the channels already joined to, broadcast the latest channel context to the subscribing app.
+            // Note 1: This might result in multiple broadcast messages (including multiple for the same context and listener)
+            client.joinedChannels.forEach((subscribedChannel) => {
+                autoBroadCastToSpecifiedClient({
+                    uuid,
+                    globalSubscription: true,
+                    channel: subscribedChannel,
+                    contextType,
+                    targetSubscriberId,
+                    resolverState: state.resolver,
+                    cmd,
+                });
+            });
+        }
+        releaseQueuedMessages({
+            state,
+            uuid,
+            channel,
+            cmd,
+            type: "broadcast",
+            contextType,
+        });
+    })
+        .addCase(actions.unsubscribeContext, (state, action) => {
+        const fsa = action.payload;
+        const { contextType } = fsa.payload;
+        const { channel, uuid } = fsa.meta;
+        let client = state.resolver.clients[uuid];
+        if (!client)
+            return;
+        let { subscriptions } = client;
+        let { channels } = subscriptions;
+        const thisContextType = contextType !== null && contextType !== void 0 ? contextType : "*";
+        if (channel && channels[channel]) {
+            delete channels[channel].contexts[thisContextType];
+            if (!Object.keys(channels[channel].contexts).length)
+                delete channels[channel].contexts[thisContextType];
+            if (!Object.keys(channels[channel].contexts) && !Object.keys(channels[channel].intents))
+                delete channels[channel];
+        }
+        else {
+            const { contexts } = subscriptions.globals;
+            delete contexts[thisContextType];
+        }
+    })
+        .addCase(actions.joinChannels, (state, action, cmd) => {
+        var _a;
+        const fsa = action.payload;
+        const { uuid } = fsa.meta;
+        const { channels: channelsToAdd } = fsa.payload;
+        const client = state.resolver.clients[uuid];
+        if (!client) {
+            Logger.system.warn(`Interop.resolver.joinChannels: client ${uuid} unknown so join skipped`);
+            return;
+        }
+        const joinedChannels = (_a = client === null || client === void 0 ? void 0 : client.joinedChannels) !== null && _a !== void 0 ? _a : [];
+        // For each channel joined, broadcast the latest channel context to the subscribing app.
+        // Note 1: the broadcast reducer will handle when client doesn't have a listener or isn't authorized.
+        // Note 2: Currently Finsemble's interopService allows a client to join multiple channels. We'll reevaluate this later, given FDC3 limits a client to joining only one channel at a time.
+        channelsToAdd.forEach((channel) => {
+            var _a;
+            if (joinedChannels.includes(channel)) {
+                Logger.system.warn(`Interop.resolver.joinChannels: ${channel} skipped because already joined`);
+            }
+            else {
+                joinedChannels.push(channel);
+                // autoBroadcast for join will only apply to the client's global subscriptions
+                let contextList = Object.values((_a = client.subscriptions.globals.contexts) !== null && _a !== void 0 ? _a : {});
+                Logger.system.debug(`Interop.resolver.joinChannels: joining ${channel} for ${uuid}`, contextList);
+                // for each of the client's context subscriptions on the channel, broadcast the last corresponding context.
+                contextList.forEach((currentContext) => {
+                    autoBroadCastToSpecifiedClient({
+                        uuid,
+                        globalSubscription: true,
+                        channel,
+                        contextType: currentContext.context.type,
+                        targetSubscriberId: currentContext.meta.targetSubscriberId,
+                        resolverState: state.resolver,
+                        cmd,
+                    });
+                });
+            }
+            // must save here since will be a different array reference for first channel joined
+            state.resolver.clients[uuid].joinedChannels = joinedChannels;
+        });
+    })
+        .addCase(actions.leaveChannels, (state, action) => {
+        var _a;
+        const fsa = action.payload;
+        const { uuid } = fsa.meta;
+        const { channels: channelsToRemove } = fsa.payload;
+        const client = state.resolver.clients[uuid];
+        const joinedChannels = (_a = client === null || client === void 0 ? void 0 : client.joinedChannels) !== null && _a !== void 0 ? _a : [];
+        const channelsToLeaveFrom = channelsToRemove !== null && channelsToRemove !== void 0 ? channelsToRemove : joinedChannels;
+        if (client)
+            state.resolver.clients[uuid].joinedChannels = channelsToRemove
+                ? joinedChannels.filter((name) => !channelsToRemove.includes(name))
+                : [];
+        cleanupStaleChannels(channelsToLeaveFrom, state.resolver);
+    })
+        .addCase(actions.registerSelectConnectChannel, (state, action) => {
+        const selectConnectChannel = action.payload;
+        state.resolver.selectConnectChannels[selectConnectChannel.name] = selectConnectChannel;
+    })
+        .addCase(actions.open, (state, action, cmd) => {
+        const { actionId } = action.payload;
+        const { fsa } = action.payload;
+        const { context, target } = fsa.payload;
+        const { uuid } = fsa.meta;
+        const client = state.resolver.clients[uuid];
+        const pendingContextBroadcastMessage = {
+            type: "broadcast",
+            payload: {
+                context,
+            },
+            meta: {
+                uuid: fsa.meta.uuid,
+                // Prevent the opening app from accidentally having its local context state set to the one we're passing to the new app
+                setSenderContext: false,
+            },
+        };
+        Logger.system.debug("Interop.resolver.open target and pending message", {
+            target,
+            pendingContextBroadcastMessage,
+        });
+        const appId = appIdFromTargetApp(state.resolver.apps.definitions, target);
+        if (!appId) {
+            Logger.system.error(`App ${fsa.meta.uuid} failed to open target ${target} because it does not have an unambiguous identifier found in appD.`, state.resolver.apps.definitions);
+            const actionResult = {
+                type: "open",
+                error: OpenError.ErrorOnLaunch,
+            };
+            setActionResult(actionId, actionResult);
+            return;
+        }
+        const authorized = filterForAppAuthorization({
+            state,
+            originClientUuid: fsa.meta.uuid,
+            contextType: (context === null || context === void 0 ? void 0 : context.type) || "",
+            destinationAppIdList: [appId],
+        });
+        const isValid = authorized.length > 0;
+        if (isValid) {
+            // opening the app is an async function because we need to wait for a windowName to be assigned
+            // actions.openedApp receives the openApp results and then completes delivery of context
+            cmd.run(openApp, {
+                args: [
+                    {
+                        actionId,
+                        appId,
+                        pendingMessage: context ? pendingContextBroadcastMessage : null,
+                        originatingAppId: client.appId,
+                        originatingAppWindow: client.windowName,
+                        appDefinitions: unImmer(state.resolver.apps.definitions),
+                    },
+                ],
+                successActionCreator: actions.openedApp,
+            });
+        }
+        else {
+            Logger.system.log(`Warning: App ${fsa.meta.uuid} tried to open app ${appId}, despite not being authorized.`);
+            const actionResult = {
+                type: "open",
+                error: OpenError.ErrorOnLaunch,
+            };
+            setActionResult(actionId, actionResult);
+        }
+    })
+        // triggered in open to handle openApp results -- see cmd.run(openApp...)
+        .addCase(actions.openedApp, (state, action) => {
+        var _a, _b;
+        const { actionId, error, windowName, pendingMessage } = action.payload;
+        Logger.system.debug(`Interop.resolver.openedApp ${windowName}`, error, pendingMessage);
+        if (!error && windowName && pendingMessage) {
+            // No setActionResult is done here because a successful result won't be sent until initial FDC3 context or intent message is broadcast to the opening client.
+            // Append actionId to signal action response must be sent when the client's initialization message is sent to it.
+            const modifiedPendingMessage = Object.assign(Object.assign({}, pendingMessage), { meta: Object.assign(Object.assign({}, pendingMessage.meta), { pendingActionId: actionId }) });
+            state.resolver.queue[windowName] = ((_a = state.resolver.queue[windowName]) !== null && _a !== void 0 ? _a : []).concat([
+                {
+                    pendingMessage: modifiedPendingMessage,
+                    timestamp: Date.now(),
+                },
+            ]);
+        }
+        else if (error) {
+            Logger.system.error("open failed due to openApp error", error, windowName);
+            const actionResult = actionId.type === "raiseIntent"
+                ? {
+                    type: "raiseIntent",
+                    error: ResolveError.NoAppsFound,
+                }
+                : {
+                    type: "open",
+                    error: OpenError.AppNotFound,
+                };
+            setActionResult(actionId, actionResult);
+        }
+        else if (windowName && !pendingMessage) {
+            // no context was specified in the open for this path
+            // check if window already registered
+            const uuids = uuidsFromWindowName({ clients: state.resolver.clients, windowName });
+            const existingUuid = uuids.length === 0 ? null : uuids[0];
+            if (uuids.length > 1) {
+                Logger.system.warn(`Interop.resolver.openedApp found multiple existing clients with same window name ${windowName}.`);
+            }
+            if (existingUuid && ((_b = state.resolver.clients[existingUuid]) === null || _b === void 0 ? void 0 : _b.readiness) === "ready") {
+                // respond to the app that made the open request; this is only for when the open request didn't contain an initial context (otherwise respond when context listener is subscribed to))
+                Logger.system.debug(`Interop.resolver.completeRegistration setting open result for ${windowName}.`);
+                setActionResult(actionId, { type: "open" });
+            }
+            else {
+                // the window hasn't completed registration yet
+                // so save actionId so completeRegistration action can respond to it
+                state.resolver.pendingOpenActionIds[windowName] = actionId;
+                Logger.system.debug("Interop.resolver.openedApp: no initial context specified");
+            }
+        }
+        else {
+            Logger.system.error("Interop.resolver.openedApp interopAssertion failure -- null path taken", error, windowName, pendingMessage);
+        }
+    })
+        .addCase(actions.raiseIntent, (state, action, cmd) => {
+        var _a;
+        const { actionId } = action.payload;
+        const { fsa } = action.payload;
+        const { intent: intentName, context, target } = fsa.payload;
+        const { uuid } = fsa.meta;
+        const client = state.resolver.clients[uuid];
+        // Get a filtered list of AppIntent objects that match the given intentName and/or context and optionally a target app.
+        // Note that AppIntent itself contains a list of apps, so the `appIntents` object is actually a two dimensional array
+        // This is because raiseIntentByContext requires such a two dimensional array. See comments for ResolutionList type.
+        const appIntents = findAndFilterAppIntents({
+            resolverState: state.resolver,
+            intentName,
+            context,
+            target,
+        });
+        // Get a second list which only contains launchable apps. (This also excludes singletons that are already running).
+        const launchableAppIntents = findAndFilterAppIntents({
+            resolverState: state.resolver,
+            intentName,
+            context,
+            target,
+            filterNotLaunchable: true,
+            filterOpenSingletons: true,
+        });
+        /**
+         * Build a multi-dimensional array of recipients. There is an entry for each known intent (each intent)
+         * from state.resolver.intent - which was generated from appd entries.
+         *
+         * Within each of these entries there is a list of launchable apps (those that have intents registered in their
+         * appd entries) and open apps (those which are running and have called addIntentListener()).
+         *
+         * The reason we build a multi-dimensional array is because this reducer may have been called only with a context.
+         * The resulting `appIntents` list might therefore resolve to a number of intents that all accept that context.
+         * See raiseIntentForContext().
+         */
+        let resolutionMultiArray = appIntents.map((appIntent) => {
+            var _a, _b, _c, _d;
+            // Get lists of resolution objects, both for launchable apps and open apps
+            // The list of intents and corresponding app choices that is launchable is potentially a subset of the broader list
+            const registeredLaunchableApps = (_b = (_a = launchableAppIntents.find((thisIntentData) => thisIntentData.intent.name === appIntent.intent.name)) === null || _a === void 0 ? void 0 : _a.apps) !== null && _b !== void 0 ? _b : [];
+            const openAppsWithHandler = getRunningAppsForIntent({
+                state,
+                target,
+                intent: appIntent.intent.name,
+            });
+            return {
+                launchableApps: filterUnauthorizedRecipients({
+                    state,
+                    uuid: fsa.meta.uuid,
+                    intentName,
+                    contextType: (_c = fsa.payload.context) === null || _c === void 0 ? void 0 : _c.type,
+                    which: "apps",
+                    candidates: registeredLaunchableApps.map((meta) => {
+                        return {
+                            meta,
+                            appId: meta.appId,
+                        };
+                    }),
+                }),
+                openApps: filterUnauthorizedRecipients({
+                    state,
+                    uuid: fsa.meta.uuid,
+                    intentName,
+                    contextType: (_d = fsa.payload.context) === null || _d === void 0 ? void 0 : _d.type,
+                    which: "uuids",
+                    candidates: openAppsWithHandler,
+                }),
+                intent: appIntent.intent,
+            };
+        });
+        /**
+         * Generate a list of all the running apps that have registered to listen for the intent specified in the fsa.
+         * If the fsa doesn't have an intent (e.g. this reducer is the result of a call to getIntentsByContext) then
+         * this will result in any empty array (those subscribers will be picked up when the resolutionMultiArray is generated below).
+         */
+        const runningAppsWithHandler = getRunningAppsForIntent({
+            state,
+            target,
+            intent: intentName,
+        });
+        /**
+         * Add any "dynamic" intent subscribing clients to the multi-array. These are clients that have called addIntentListener()
+         * on an unknown intent (one that is not in any appd entry).
+         */
+        if (intentName && !resolutionMultiArray.some((resolutionList) => resolutionList.intent.name === intentName)) {
+            resolutionMultiArray = resolutionMultiArray.concat({
+                launchableApps: [],
+                openApps: filterUnauthorizedRecipients({
+                    state,
+                    uuid: fsa.meta.uuid,
+                    intentName,
+                    contextType: (_a = fsa.payload.context) === null || _a === void 0 ? void 0 : _a.type,
+                    which: "uuids",
+                    candidates: runningAppsWithHandler,
+                }),
+                intent: {
+                    name: intentName,
+                    displayName: intentName,
+                },
+            });
+        }
+        const numberOfAuthorizedRecipients = resolutionMultiArray
+            .map((resolutionList) => resolutionList.launchableApps.length + resolutionList.openApps.length)
+            .reduce((acc, cur) => acc + cur, 0);
+        // Provide helpful warning messages to developers for potential mismatches between AppD entries and addIntentListener()
+        if (intentName && state.resolver.intents[intentName]) {
+            const anyRecipients = launchableAppIntents.length > 0 || runningAppsWithHandler.length > 0;
+            if (!anyRecipients) {
+                Logger.warn(`No app was found for "raiseIntent ${intentName}" although the intent is defined.  This might be the desired behavior, but if not then review the AppD config for apps than handle ${intentName}. One possible cause is if the app is not launchable and hasn't registered.`);
+            }
+            else if (!numberOfAuthorizedRecipients) {
+                Logger.warn(`No app was found for "raiseIntent ${intentName}" after filtering for authorization, although the intent is defined.  This might be the desired behavior, but if not then review the AppD config authorization rules. Also confirm the target app was authenticated when it registered.`);
+            }
+        }
+        // Raising the intent is always a multi-step acton, so pull together the requisite intent data for the next steps.
+        // Set flag to specify if UI Resolver is available and needed to decide which app handles the intent
+        const isAppResolutionNeeded = numberOfAuthorizedRecipients > 1 && state.resolver.config.registeredUIResolver !== null;
+        Logger.system.log(`Interop.resolver.raiseIntent needs resolution=${isAppResolutionNeeded}`, {
+            appIntents,
+            launchableAppIntents,
+            resolutionMultiArray,
+        });
+        // if UI resolver is needed, then initiate handshake with it
+        if (isAppResolutionNeeded) {
+            sendIntentToAppResolver({
+                state,
+                cmd,
+                actionId,
+                fsa,
+                resolutionList: resolutionMultiArray,
+                originatingAppWindow: client.windowName,
+            });
+            return;
+        }
+        /**
+         * Automatically pick the app. Either because no UI resolution is necessary, or the UI resolver isn't registered.
+         * If the UI resolver is unregistered, then the first app in the list of possibilities is picked.
+         */
+        const appToOpen = resolutionMultiArray.find((listItem) => listItem.launchableApps.length > 0);
+        const alreadyOpenApp = resolutionMultiArray.find((listItem) => listItem.openApps.length > 0);
+        if (appToOpen) {
+            openAppForIntent({
+                state,
+                cmd,
+                fsa,
+                actionId,
+                appId: appToOpen.launchableApps[0].appId,
+                originatingAppId: client.appId,
+                originatingAppWindow: client.windowName,
+            });
+        }
+        else if (alreadyOpenApp) {
+            sendIntentToRunningApp({
+                state,
+                fsa,
+                cmd,
+                app: alreadyOpenApp.openApps[0],
+            });
+        }
+        else {
+            // Return a ResolveError to the Desktop Agent because no valid app was found to handle the intent
+            // Perhaps should be a user notification
+            Logger.warn(`No app found for FDC3 intent request. Intent=\"${intentName}\" Optional Target App=\"${target}\"`);
+            const raiseIntentResult = {
+                type: "raiseIntent",
+                error: ResolveError.NoAppsFound,
+            };
+            setActionResult(actionId, raiseIntentResult);
+        }
+    })
+        // triggered by raiseIntent to handle UI Resolver response -- see cmd.run(resolveIntentApps...)
+        .addCase(actions.handleUIResolutionResponse, (state, action, cmd) => {
+        const fsa = action.payload;
+        const { actionId, resolverResolution, pendingMessage } = fsa;
+        const { intent, windowName, selectedApp, originatingAppWindow } = resolverResolution;
+        let updatedPendingIntentMessage = unImmer(pendingMessage);
+        state.resolver.apps.intentResolutionInProgress = false;
+        state.resolver.apps.intentResolutionCurrentActionId = null;
+        // if UI resolution returned a selected intent name, use if for the pending intent
+        if (intent) {
+            updatedPendingIntentMessage.payload.intent = intent;
+        }
+        // if resolve error, which might be due to user cancel, then don't resolve the intent
+        if (resolverResolution.error) {
+            Logger.warn(`Interop.resolver.handleUIResolutionResponse. ${resolverResolution.error}`, {
+                state,
+                action,
+                resolverResolution,
+            });
+            const raiseIntentResult = {
+                type: "raiseIntent",
+                error: resolverResolution.error,
+            };
+            setActionResult(actionId, raiseIntentResult);
+            // if app is already open, then immediately broadcast the intent to that app
+        }
+        else if (windowName) {
+            const uuids = uuidsFromWindowName({ clients: state.resolver.clients, windowName });
+            if (uuids.length) {
+                const uuid = uuids[0];
+                const interopBroadcast = Object.assign(Object.assign({}, updatedPendingIntentMessage), { meta: Object.assign(Object.assign({}, updatedPendingIntentMessage.meta), { pendingActionId: actionId, 
+                        // Ensure that the broadcast goes to the specific app selected by the end user
+                        to: uuid }) });
+                cmd === null || cmd === void 0 ? void 0 : cmd.action(actions.broadcast(interopBroadcast));
+                // no setActionResult here because a successful result won't be sent until initial intent message is broadcast to the app client
+            }
+            else {
+                Logger.error(`Interop.resolver.handleUIResolutionResponse client ${windowName} not found. App may have been terminated during intent resolution`);
+                const raiseIntentResult = {
+                    type: "raiseIntent",
+                    error: ResolveError.NoAppsFound,
+                };
+                setActionResult(actionId, raiseIntentResult);
+            }
+        }
+        else if (selectedApp && selectedApp.appId) {
+            // else open the app selected by the end user. The intent will be queued by `openedApp` until the app subscribes for the intent.
+            cmd === null || cmd === void 0 ? void 0 : cmd.run(openApp, {
+                args: [
+                    {
+                        actionId,
+                        appId: selectedApp.appId,
+                        pendingMessage: updatedPendingIntentMessage,
+                        originatingAppId: originatingAppWindow !== null && originatingAppWindow !== void 0 ? originatingAppWindow : "undefined",
+                        originatingAppWindow: originatingAppWindow !== null && originatingAppWindow !== void 0 ? originatingAppWindow : "undefined",
+                        appDefinitions: unImmer(state.resolver.apps.definitions),
+                    },
+                ],
+                successActionCreator: actions.openedApp,
+            });
+        }
+        else {
+            Logger.error("No appId returned from UI resolver");
+        }
+        Logger.system.debug("Interop.resolver.handleUIResolutionResponse resolution", {
+            state,
+            action,
+            resolverResolution,
+        });
+    })
+        .addCase(actions.subscribeIntent, (state, action, cmd) => {
+        var _a, _b, _c, _d;
+        const fsa = action.payload;
+        const { intent: intentName } = fsa.payload;
+        const { uuid } = fsa.meta;
+        const client = state.resolver.clients[uuid];
+        client.subscriptions.globals.intents[intentName] = true;
+        const appDefinition = (_a = state.resolver.apps.definitions[client.appId]) !== null && _a !== void 0 ? _a : {};
+        // All apps should have AppD entries that identify the intents that they will listen for but
+        // if not then provide a clear message for app developers.
+        const intentIsRegisteredInAppD = (_b = appDefinition === null || appDefinition === void 0 ? void 0 : appDefinition.intents) === null || _b === void 0 ? void 0 : _b.some((intent) => intent.name === intentName);
+        if (!intentIsRegisteredInAppD) {
+            const friendlyName = appDefinition ? getFriendlyName(appDefinition) : client.appId;
+            const logMessage = `"${friendlyName}" added intent listener for "${intentName}" which isn't in its AppD entry. Intents will be processed but an AppD entry must include "${intentName}" for full functionality.`;
+            Logger.system.error(logMessage);
+            const messageTitle = "FDC3 AppD Config Issue";
+            const messageDetails = `"${friendlyName}" added intent listener for "${intentName}" which isn't in its AppD entry. Check the central logger for more information.`;
+            const devModeOnly = true;
+            cmd === null || cmd === void 0 ? void 0 : cmd.run(notifyEndUser, {
+                args: [messageTitle, messageDetails, devModeOnly],
+            });
+        }
+        // find the matching intent in app definitions
+        let matchingIntent = (_d = (_c = state.resolver.apps.definitions[client.appId]) === null || _c === void 0 ? void 0 : _c.intents) === null || _d === void 0 ? void 0 : _d.find((intent) => intent.name === intentName);
+        // each time a listener is added, mark it so cleanAndVerify can later confirm all the expected listeners were added
+        if (matchingIntent) {
+            matchingIntent.appListenerAdded = true;
+        }
+        releaseQueuedMessages({
+            state,
+            uuid,
+            cmd,
+            type: "raiseIntent",
+            intent: intentName,
+        });
+    })
+        .addCase(actions.unsubscribeIntent, (state, action) => {
+        const fsa = action.payload;
+        const { intent: intentName } = fsa.payload;
+        const { uuid } = fsa.meta;
+        const client = state.resolver.clients[uuid];
+        delete client.subscriptions.globals.intents[intentName];
+    })
+        .addCase(actions.addAppDefinitions, (state, action) => {
+        const fsa = action.payload;
+        const { apps } = fsa.payload;
+        Object.values(apps).forEach((definition) => {
+            state.resolver.apps.definitions[definition.appId] = definition;
+            state.resolver.intents = appendedIntentData(state.resolver, definition);
+        });
+        Logger.system.debug("Interop.resolver.addAppDefinitions result", state.resolver.apps.definitions);
+    })
+        .addCase(actions.removeAppDefinitions, (state, action) => {
+        const fsa = action.payload;
+        const { apps } = fsa.payload;
+        const { definitions } = state.resolver.apps;
+        apps.forEach((appId) => {
+            delete definitions[appId];
+        });
+    })
+        .addCase(actions.registerUIResolver, (state, action) => {
+        const fsa = action.payload;
+        const { uuid } = fsa.meta;
+        state.resolver.config.registeredUIResolver = uuid;
+    })
+        .addCase(actions.resetDetectedLoopState, (state, action) => {
+        const { senderUuid, newTimerId } = action.payload;
+        const { loopDetectionMap } = state.resolver;
+        let loopDetectionRecord = loopDetectionMap[senderUuid];
+        loopDetectionRecord.timerId = newTimerId;
+        loopDetectionRecord.count = 0;
+        loopDetectionRecord.loopNotificationIssued = false;
+        Logger.system.debug("Interop.resolver.resetDetectedLoopState record", loopDetectionRecord);
+    })
+        .addCase(actions.addIntentListenerMaxInitializationTimeout, (state, action) => {
+        state.resolver.addIntentListenerMaxInitializationTimeout = action.payload;
+        Logger.system.debug("Interop.resolver.addIntentListenerMaxInitializationTimeout added", action.payload);
+    });
+};
+// Used by Live Mocha tests to control state or simulate user actions. See fdc3Tests.js for example where Testpoint.triggerAction causes this onAction() to fire.
+testPoint.onAction("fdc3.resolver.disableCleanupStaleChannels", () => {
+    testPoint.state.disableCleanupStaleChannels = true;
+});
+testPoint.onAction("fdc3.resolver.reenableCleanupStaleChannels", () => {
+    testPoint.state.disableCleanupStaleChannels = false;
+});
+export default {
+    getInitialState,
+    addReducerCases,
+    actions,
+    workspaceUuid,
+    initialize: (store) => {
+        store;
+    },
+};
+//# sourceMappingURL=resolver.js.map