@qlik/api 1.29.0 → 1.31.0

package/chunks/{MGXEGSJC.js → UZTIZ4H5.js}

@@ -1,87 +1,138 @@
+import {
+  getHumanReadableSocketClosedErrorMessage
+} from "./ETNHFALU.js";
 import {
   getPlatform,
   handleAuthenticationError,
   invokeFetch,
   isWindows,
   toValidWebsocketLocationUrl
-} from "./NBW6PHZU.js";
+} from "./FKDGGR2O.js";
 import "./3RGGGGAR.js";
 import {
   isBrowser
 } from "./2ZQ3ZX7F.js";
 
-// src/qix/session/websocket-errors.ts
-var closeCodeEngineTerminating = 4003;
-var closeCodeEngineAbnormalClosure = 1006;
-var closeCodeEngineProxyGeneric = 4200;
-var closeCodeClientTimeout = 4201;
-var closeCodeBadRequest = 4202;
-var closeCodePermissions = 4203;
-var closeCodeNotFound = 4204;
-var closeCodeTooManyRequests = 4205;
-var closeCodeNetwork = 4206;
-var closeCodeDependencyGeneric = 4210;
-var closeCodeDependencyUnavailable = 4211;
-var closeCodeEngineGeneric = 4220;
-var closeCodeEntitlement = 4230;
-var closeCodeNoEnginesAvailable = 4240;
-var CloseCodeSessionReservationMissing = 4222;
-var closeCodeMessages = {
-  [closeCodeEngineTerminating]: "The engine is in terminating state",
-  [closeCodeEngineAbnormalClosure]: "The engine is abnormally closed",
-  [closeCodeEngineProxyGeneric]: "A problem occurred in engine-proxy",
-  [closeCodeClientTimeout]: "The client has closed the connection",
-  [closeCodeBadRequest]: "The provided request is invalid and/or malformed",
-  [closeCodePermissions]: "No permission to open the app",
-  [closeCodeNotFound]: "App not found",
-  [closeCodeTooManyRequests]: "Too many requests have been sent in a given amount of time",
-  [closeCodeNetwork]: "Networking issues",
-  [closeCodeDependencyGeneric]: "A problem occurred in a dependency of engine-proxy",
-  [closeCodeDependencyUnavailable]: "A dependency is unavailable and not serving any requests",
-  [closeCodeEngineGeneric]: "A problem occurred in an engine",
-  [closeCodeEntitlement]: "You are not entitled to perform that operation",
-  [closeCodeNoEnginesAvailable]: "There are currently no engines available",
-  [CloseCodeSessionReservationMissing]: "The reserved session is missing"
-};
-var uknownCloseErrorMessage = "websocket closed for unknown reason";
-function getHumanReadableSocketClosedErrorMessage(err, { appId, hostConfig }) {
-  const closeCode = err?.original?.code;
-  const closeMessage = closeCode ? closeCodeMessages[closeCode] || uknownCloseErrorMessage : err.message;
-  if (hostConfig?.host) {
-    return `Failed to open app ${appId} on ${hostConfig?.host}: ${closeMessage}`;
-  } else {
-    return `Failed to open app ${appId}: ${closeMessage}`;
-  }
-}
-
-// src/qix/session/shared-sessions.ts
-var globalEventListeners = /* @__PURE__ */ new Set();
-function globalOnWebSocketEvent(listener) {
-  globalEventListeners.add(listener);
-  return () => {
-    globalEventListeners.delete(listener);
+// src/qix/app-session.ts
+var isBrowserEnvironment = isBrowser();
+function createAppSession(sharedSession) {
+  const listeners = /* @__PURE__ */ new Set();
+  let alreadyClosed = false;
+  const sharedSessionClient = {
+    onWebSocketEvent(event) {
+      listeners.forEach((listener) => {
+        listener(event);
+      });
+    }
   };
-}
-var globalStateListeners = /* @__PURE__ */ new Set();
-function globalOnStateChange(listener) {
-  globalStateListeners.add(listener);
-  return () => {
-    globalStateListeners.delete(listener);
+  const appSession = {
+    getDoc: () => sharedSession.getDoc(),
+    onWebSocketEvent(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    resume: async () => {
+      return sharedSession.resume();
+    },
+    close(props) {
+      if (!alreadyClosed) {
+        alreadyClosed = true;
+        const defaultDelay = isBrowserEnvironment ? 5e3 : -1;
+        return sharedSession.removeClient(sharedSessionClient, props?.websocketCloseDelay ?? defaultDelay);
+      }
+      return Promise.resolve();
+    },
+    /* Only for test cases */
+    // @ts-expect-error ts(2353)
+    _listeners: listeners
   };
+  sharedSession.addClient(sharedSessionClient);
+  return appSession;
 }
-async function resumeAll() {
-  const promises = [];
-  Object.keys(globalState.sessionStates).forEach((key) => {
-    const state = globalState.sessionStates[key];
-    if (state === "suspended") {
-      promises.push(sharedSessions[key].resume());
+
+// src/qix/external-app-session.ts
+function createExternalSharedSession(externalApp, onWebSocketEvent2, appSessionProps) {
+  const clients = [];
+  const sharedSession = {
+    getDoc: () => externalApp,
+    addClient(client) {
+      const index = clients.indexOf(client, 0);
+      if (index === -1) {
+        clients.push(client);
+      }
+    },
+    removeClient(client) {
+      const index = clients.indexOf(client, 0);
+      if (index > -1) {
+        clients.splice(index, 1);
+      }
+      return Promise.resolve();
+    },
+    initialActionsUpdated: () => {
+    },
+    clientsCount: () => clients.length,
+    resume: async () => {
+      try {
+        await externalApp.then((doc) => doc.session?.resume());
+      } catch (err) {
+        console.warn(err);
+      }
+    }
+  };
+  const triggerEventListeners = (event) => {
+    onWebSocketEvent2(event);
+    for (const client of clients) {
+      client.onWebSocketEvent(event);
     }
+  };
+  void externalApp.then((app) => {
+    app.session.on("opened", (event) => {
+      const wsEvent = {
+        eventType: "opened",
+        ...appSessionProps,
+        ...event
+      };
+      triggerEventListeners(wsEvent);
+    });
+    app.session.on("closed", (event) => {
+      const wsEvent = {
+        eventType: "closed",
+        ...appSessionProps,
+        ...event
+      };
+      triggerEventListeners(wsEvent);
+    });
+    app.session.on("suspended", (event) => {
+      const wsEvent = {
+        eventType: "suspended",
+        ...appSessionProps,
+        ...event
+      };
+      triggerEventListeners(wsEvent);
+    });
+    app.session.on("resuming", (event) => {
+      const wsEvent = {
+        eventType: "resuming",
+        ...appSessionProps,
+        ...event
+      };
+      triggerEventListeners(wsEvent);
+    });
+    app.session.on("resumed", (event) => {
+      const wsEvent = {
+        eventType: "resumed",
+        ...appSessionProps,
+        ...event
+      };
+      triggerEventListeners(wsEvent);
+    });
   });
-  await Promise.all(promises);
-  return Promise.resolve();
+  return sharedSession;
 }
-var initialActions = {};
-var sharedSessions = {};
+
+// src/qix/internal/global-app-session.id.ts
 function toGlobalAppSessionId({
   appId,
   identity,
@@ -89,7 +140,8 @@ function toGlobalAppSessionId({
   withoutData,
   useReloadEngine,
   ttlSeconds,
-  workloadType
+  workloadType,
+  autoResume
 }) {
   const locationUrl = toValidWebsocketLocationUrl(hostConfig);
   let url = `${locationUrl}/${appId}`;
@@ -108,38 +160,142 @@ function toGlobalAppSessionId({
   if (workloadType) {
     url += `?workloadType=${workloadType}`;
   }
+  if (autoResume) {
+    url += "/auto-resume";
+  }
   return url;
 }
-async function runPendingInitialActions(initialActionsForApp, sharedSession, doc) {
-  for (const initialAction of initialActionsForApp) {
-    if (sharedSession.alreadyExecutedInitialActions.indexOf(initialAction) === -1) {
-      sharedSession.alreadyExecutedInitialActions.push(initialAction);
-      await initialAction(doc);
+
+// src/qix/global-events.ts
+var globalEventListeners = /* @__PURE__ */ new Set();
+var globalStateListeners = /* @__PURE__ */ new Set();
+function onWebSocketEvent(listener) {
+  globalEventListeners.add(listener);
+  return () => {
+    globalEventListeners.delete(listener);
+  };
+}
+function onCombinedWebSocketStateChange(listener) {
+  globalStateListeners.add(listener);
+  return () => {
+    globalStateListeners.delete(listener);
+  };
+}
+var globalState = {
+  sessionStates: {},
+  state: "closed"
+};
+function stateListener(key, event) {
+  if (event.eventType === "closed") {
+    delete globalState.sessionStates[key];
+  } else {
+    globalState.sessionStates[key] = event.eventType;
+  }
+  const states = Object.values(globalState.sessionStates);
+  let anySuspended = false;
+  let anyResuming = false;
+  for (const state of states) {
+    if (state === "suspended") {
+      anySuspended = true;
+    } else if (state === "resuming") {
+      anyResuming = true;
+    }
+  }
+  let newState;
+  if (states.length === 0) {
+    newState = "closed";
+  } else if (anySuspended) {
+    newState = "suspended";
+  } else if (anyResuming) {
+    newState = "resuming";
+  } else {
+    newState = "open";
+  }
+  if (globalState.state !== newState) {
+    globalState.state = newState;
+    for (const fn of globalStateListeners) {
+      fn({ state: newState });
     }
   }
 }
-function addInitialSharedSessionCreationAction(openAppSessionProps, action) {
-  const key = toGlobalAppSessionId(openAppSessionProps);
-  let initialActionArray = initialActions[key];
-  if (!initialActionArray) {
-    initialActionArray = initialActions[key] = [];
+function triggerGlobalWebSocketEventListeners(event) {
+  for (const fn of globalEventListeners) {
+    fn(event);
   }
-  initialActionArray.push(action);
-  const existingSharedSession = sharedSessions[key];
-  if (existingSharedSession) {
-    existingSharedSession.docPromise.then((doc) => {
-      if (doc) {
-        runPendingInitialActions(initialActionArray, existingSharedSession, doc);
+  stateListener(toGlobalAppSessionId(event), event);
+}
+
+// src/qix/session/shared-sessions-phoenix.ts
+function createSharedPhoenixSession(props, { onClose, onWebSocketEvent: onWebSocketEventGlobal, getInitialAppActions }) {
+  try {
+    const clients = [];
+    const onWebSocketEvent2 = (event) => {
+      onWebSocketEventGlobal(event);
+      for (const client of clients) {
+        client.onWebSocketEvent(event);
       }
+    };
+    const phoenixConnectionPromise = import("./M64RLKVG.js").then((module) => {
+      return module.createPhoenixConnectionEntrypoint(props, {
+        onWebSocketEvent: onWebSocketEvent2,
+        getInitialAppActions
+      });
     });
+    const docPromise = phoenixConnectionPromise.then((phoenixConnection) => phoenixConnection.doc);
+    const sharedSession = {
+      getDoc: () => docPromise,
+      addClient(client) {
+        const index = clients.indexOf(client, 0);
+        if (index === -1) {
+          clients.push(client);
+        }
+      },
+      removeClient(client, closeDelay) {
+        if (clients.length === 1) {
+          void phoenixConnectionPromise.then((phoenixConnection) => {
+            phoenixConnection.stopActivityMonitoring();
+          });
+        }
+        const actuallyRemove = () => {
+          const index = clients.indexOf(client, 0);
+          if (index > -1) {
+            clients.splice(index, 1);
+          }
+          if (clients.length === 0) {
+            onClose();
+            void phoenixConnectionPromise.then((phoenixConnection) => {
+              phoenixConnection.close();
+            });
+          }
+        };
+        if (closeDelay > 0) {
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              actuallyRemove();
+              resolve();
+            }, closeDelay);
+          });
+        } else {
+          actuallyRemove();
+          return Promise.resolve();
+        }
+      },
+      resume: async () => {
+        void phoenixConnectionPromise.then((session) => session.resume());
+      },
+      initialActionsUpdated() {
+        void phoenixConnectionPromise.then((session) => session.initialAppActionsUpdated());
+      },
+      clientsCount: () => clients.length
+    };
+    return sharedSession;
+  } catch (err) {
+    console.error(err);
+    throw err;
   }
-  return () => {
-    const index = initialActionArray.indexOf(action);
-    if (index > -1) {
-      initialActionArray.splice(index, 1);
-    }
-  };
 }
+
+// src/qix/session/shared-sessions.ts
 function listenForWindowsAuthenticationInformation(session) {
   let resolveAuthSuggestedInWebsocket;
   const authSuggestedInWebsocket = new Promise((resolve, reject) => {
@@ -160,10 +316,10 @@ function listenForWindowsAuthenticationInformation(session) {
   );
   return authSuggestedInWebsocket;
 }
-async function createAndSetupEnigmaSession(props, canRetry) {
-  const { createEnigmaSession } = await import("./QOOCP2TS.js");
-  const session = await createEnigmaSession(props);
-  setupSessionListeners(session, props);
+async function createAndSetupEnigmaSession(props, canRetry, onWebSocketEvent2) {
+  const { createEnigmaSessionEntrypoint } = await import("./M64RLKVG.js");
+  const session = await createEnigmaSessionEntrypoint(props);
+  setupSessionListeners(session, props, onWebSocketEvent2);
   let global;
   if (await isWindows(props.hostConfig)) {
     const loginInfoPromise = listenForWindowsAuthenticationInformation(session);
@@ -177,7 +333,7 @@ async function createAndSetupEnigmaSession(props, canRetry) {
         hostConfig: props.hostConfig
       });
       if (canRetry && action.retry) {
-        return createAndSetupEnigmaSession(props, false);
+        return createAndSetupEnigmaSession(props, false, onWebSocketEvent2);
       }
       if (action.preventDefault) {
         return new Promise(() => {
@@ -192,100 +348,7 @@ async function createAndSetupEnigmaSession(props, canRetry) {
     global
   };
 }
-var globalState = {
-  sessionStates: {},
-  state: "closed"
-};
-function stateListener(key, event) {
-  if (event.eventType === "closed") {
-    delete globalState.sessionStates[key];
-  } else {
-    globalState.sessionStates[key] = event.eventType;
-  }
-  const states = Object.values(globalState.sessionStates);
-  let anySuspended = false;
-  let anyResuming = false;
-  for (const state of states) {
-    if (state === "suspended") {
-      anySuspended = true;
-    } else if (state === "resuming") {
-      anyResuming = true;
-    }
-  }
-  let newState;
-  if (states.length === 0) {
-    newState = "closed";
-  } else if (anySuspended) {
-    newState = "suspended";
-  } else if (anyResuming) {
-    newState = "resuming";
-  } else {
-    newState = "open";
-  }
-  if (globalState.state !== newState) {
-    globalState.state = newState;
-    for (const fn of globalStateListeners) {
-      fn({ state: newState });
-    }
-  }
-}
-function setupSessionListeners(session, props) {
-  const key = toGlobalAppSessionId(props);
-  const eventListener = (event) => {
-    let sharedSession = void 0;
-    let shouldHandleEvent = false;
-    if (key in sharedSessions) {
-      sharedSession = sharedSessions[key];
-      shouldHandleEvent = sharedSession.connected;
-    } else if (key in globalState.sessionStates) {
-      shouldHandleEvent = true;
-    }
-    if (!shouldHandleEvent) {
-      return;
-    }
-    stateListener(key, event);
-    for (const fn of globalEventListeners) {
-      fn(event);
-    }
-    if (sharedSession) {
-      sharedSession.clients.forEach((client) => {
-        for (const fn of client._listeners) {
-          fn(event);
-        }
-      });
-      if (event.eventType === "suspended" && shouldAutoResume(event.code)) {
-        sharedSession.resume().catch((err) => {
-        });
-      }
-    }
-  };
-  const suspendListener = (event) => {
-    if (!(key in sharedSessions)) {
-      return;
-    }
-    const sharedSession = sharedSessions[key];
-    let resumed = false;
-    let resumePromise = Promise.resolve();
-    sharedSession.resume = async () => {
-      if (!resumed) {
-        session.emit("resuming", {});
-        resumePromise = sessionResumeWithRetry(session, props.hostConfig).catch((err) => {
-          session.suspend();
-          return Promise.reject(err);
-        });
-        resumed = true;
-      }
-      return resumePromise;
-    };
-  };
-  session.on("suspended", (event) => {
-    const wsEvent = {
-      eventType: "suspended",
-      ...props,
-      ...event
-    };
-    suspendListener(wsEvent);
-  });
+function setupSessionListeners(session, props, eventListener) {
   session.on("opened", (event) => {
     const wsEvent = {
       eventType: "opened",
@@ -367,12 +430,51 @@ function shouldAutoResume(code) {
   }
   return false;
 }
-function createSharedSession(props) {
-  const { sessionPromise, globalPromise } = separatePromises(createAndSetupEnigmaSession(props, true));
+function createSharedEnigmaSession(props, { getInitialAppActions, onClose, onWebSocketEvent: onGlobalWebsocketEvent }) {
+  const clients = [];
+  const alreadyExecutedInitialActions = [];
+  async function runPendingInitialActions(initialActionsForApp, doc) {
+    for (const initialAction of initialActionsForApp) {
+      if (alreadyExecutedInitialActions.indexOf(initialAction) === -1) {
+        alreadyExecutedInitialActions.push(initialAction);
+        await initialAction(doc);
+      }
+    }
+  }
+  let resumePromise;
+  function onWebSocketEvent2(event) {
+    if (event.eventType === "suspended") {
+      resumePromise = void 0;
+      if (shouldAutoResume(event.code)) {
+        resume().catch((err) => {
+          console.error("Failed to auto-resume");
+        });
+      }
+    }
+    for (const client of clients) {
+      client.onWebSocketEvent(event);
+    }
+    onGlobalWebsocketEvent(event);
+  }
+  const { sessionPromise, globalPromise } = separatePromises(
+    createAndSetupEnigmaSession(props, true, onWebSocketEvent2)
+  );
+  async function resume() {
+    if (!resumePromise) {
+      resumePromise = (async () => {
+        let session = await sessionPromise;
+        session.emit("resuming", {});
+        await sessionResumeWithRetry(session, props.hostConfig).catch((err) => {
+          session.suspend();
+          return Promise.reject(err);
+        });
+      })();
+    }
+    return resumePromise;
+  }
   const docPromise = globalPromise.then(async (global) => {
     if (props.useSessionApp) {
-      const global2 = await sharedSession.globalPromise;
-      return global2.createSessionApp();
+      return global.createSessionApp();
     } else {
       return global.openDoc(props.appId, "", "", "", !!props.withoutData).then((doc) => {
         if (!doc) {
@@ -382,32 +484,40 @@ function createSharedSession(props) {
         return doc;
       });
     }
+  }).then(async (doc) => {
+    const initialActionsForApp = getInitialAppActions();
+    if (initialActionsForApp && doc) {
+      await runPendingInitialActions(initialActionsForApp, doc);
+    }
+    return doc;
+  }).catch((err) => {
+    closeEnigmaSession();
+    const errorWithReadableMessage = new Error(getHumanReadableSocketClosedErrorMessage(err.original || err, props));
+    Object.entries(err).forEach(([key, value]) => {
+      errorWithReadableMessage[key] = value;
+    });
+    return Promise.reject(errorWithReadableMessage);
   });
-  const key = toGlobalAppSessionId(props);
-  const clients = [];
   function closeEnigmaSession() {
-    delete sharedSessions[key];
-    return sharedSession.sessionPromise.then((session) => session.close()).catch(() => {
+    onClose();
+    return sessionPromise.then((session) => session.close()).catch(() => {
     });
   }
   const sharedSession = {
-    sessionPromise,
-    globalPromise,
-    docPromise,
-    clients,
+    getDoc: () => docPromise,
     addClient(client) {
-      const index = sharedSession.clients.indexOf(client, 0);
+      const index = clients.indexOf(client, 0);
       if (index === -1) {
-        sharedSession.clients.push(client);
+        clients.push(client);
       }
     },
     removeClient(client, closeDelay) {
       const actuallyRemove = () => {
-        const index = sharedSession.clients.indexOf(client, 0);
+        const index = clients.indexOf(client, 0);
         if (index > -1) {
-          sharedSession.clients.splice(index, 1);
+          clients.splice(index, 1);
         }
-        if (sharedSession.clients.length === 0) {
+        if (clients.length === 0) {
           closeEnigmaSession();
         }
       };
@@ -423,36 +533,15 @@ function createSharedSession(props) {
       }
       return Promise.resolve();
     },
-    alreadyExecutedInitialActions: [],
-    resume: () => {
-      return Promise.resolve();
+    resume,
+    initialActionsUpdated() {
+      getInitialAppActions();
     },
-    connected: false
+    clientsCount: () => clients.length
   };
-  sharedSession.docPromise = sharedSession.docPromise.then(async (doc) => {
-    sharedSession.connected = true;
-    const session = await sharedSession.sessionPromise;
-    session.emit("opened", {});
-    const initialActionsForApp = initialActions[key];
-    if (initialActionsForApp && doc) {
-      await runPendingInitialActions(initialActionsForApp, sharedSession, doc);
-    }
-    return doc;
-  });
-  sharedSession.docPromise = sharedSession.docPromise.catch((err) => {
-    closeEnigmaSession();
-    const errorWithReadableMessage = new Error(getHumanReadableSocketClosedErrorMessage(err, props));
-    Object.entries(err).forEach(([key2, value]) => {
-      errorWithReadableMessage[key2] = value;
-    });
-    return Promise.reject(errorWithReadableMessage);
-  });
   return sharedSession;
 }
 var onlyOnReattach = false;
-function resumeShouldRejectPromiseIfNotReattached(bool) {
-  onlyOnReattach = bool;
-}
 async function checkConnectivity(hostConfig) {
   let status = "online";
   const method = "get";
@@ -511,76 +600,80 @@ async function sessionResumeWithRetry(session, hostConfig) {
   }
   return Promise.resolve();
 }
+
+// src/qix/shared-sessions-manager.ts
+var initialActions = {};
+var sharedSessions = {};
+var externalApps = {};
 function getOrCreateSharedSession(props) {
+  const appSessionId = toGlobalAppSessionId(props);
+  const externalAppSession = externalApps[appSessionId];
+  if (externalAppSession) {
+    return externalAppSession;
+  }
   const key = toGlobalAppSessionId(props);
-  sharedSessions[key] = sharedSessions[key] || createSharedSession(props);
-  return sharedSessions[key];
-}
-function getExternalSession(externalApp, appSessionProps) {
-  const listeners = /* @__PURE__ */ new Set();
-  const appSession = {
-    _listeners: listeners,
-    getDoc: () => externalApp,
-    onWebSocketEvent: (fn) => () => {
-      appSession._listeners.add(fn);
-      return () => {
-        appSession._listeners.delete(fn);
-      };
+  if (sharedSessions[key]) {
+    return sharedSessions[key];
+  }
+  const extraProps = {
+    onClose: () => {
+      delete sharedSessions[key];
     },
-    resume: () => Promise.resolve(),
-    close: () => Promise.resolve()
-  };
-  const triggerEventListeners = (event) => {
-    for (const fn of globalEventListeners) {
-      fn(event);
+    onWebSocketEvent: triggerGlobalWebSocketEventListeners,
+    getInitialAppActions: () => {
+      return initialActions[key] || [];
     }
-    for (const fn of appSession._listeners) {
-      fn(event);
+  };
+  let session;
+  if (props.autoResume) {
+    session = createSharedPhoenixSession(props, extraProps);
+  } else {
+    session = createSharedEnigmaSession(props, extraProps);
+  }
+  sharedSessions[key] = session;
+  return sharedSessions[key];
+}
+async function resumeSuspendedSessions() {
+  await Promise.all(
+    Object.values(sharedSessions).map((sharedSession) => {
+      return sharedSession.resume();
+    })
+  );
+}
+async function resumeOnlyOnReattach() {
+  await Promise.all(
+    Object.values(sharedSessions).map((sharedSession) => {
+      return sharedSession.resume();
+    })
+  );
+}
+function addInitialAppAction(openAppSessionProps, action) {
+  const key = toGlobalAppSessionId(openAppSessionProps);
+  let initialActionArray = initialActions[key];
+  if (!initialActionArray) {
+    initialActionArray = [];
+    initialActions[key] = initialActionArray;
+  }
+  initialActionArray.push(action);
+  const existingSharedSession = sharedSessions[key];
+  if (existingSharedSession) {
+    existingSharedSession.initialActionsUpdated();
+  }
+  return () => {
+    const index = initialActionArray.indexOf(action);
+    if (index > -1) {
+      initialActionArray.splice(index, 1);
     }
   };
-  externalApp.then((app) => {
-    app.session.on("opened", (event) => {
-      const wsEvent = {
-        eventType: "opened",
-        ...appSessionProps,
-        ...event
-      };
-      triggerEventListeners(wsEvent);
-    });
-    app.session.on("closed", (event) => {
-      const wsEvent = {
-        eventType: "closed",
-        ...appSessionProps,
-        ...event
-      };
-      triggerEventListeners(wsEvent);
-    });
-    app.session.on("suspended", (event) => {
-      const wsEvent = {
-        eventType: "suspended",
-        ...appSessionProps,
-        ...event
-      };
-      triggerEventListeners(wsEvent);
-    });
-    app.session.on("resuming", (event) => {
-      const wsEvent = {
-        eventType: "resuming",
-        ...appSessionProps,
-        ...event
-      };
-      triggerEventListeners(wsEvent);
-    });
-    app.session.on("resumed", (event) => {
-      const wsEvent = {
-        eventType: "resumed",
-        ...appSessionProps,
-        ...event
-      };
-      triggerEventListeners(wsEvent);
-    });
+}
+function registerExternalAppSession(appId, enigmaDocObject) {
+  const appSessionId = toGlobalAppSessionId({ appId });
+  function onWebSocketEvent2(event) {
+    triggerGlobalWebSocketEventListeners(event);
+  }
+  externalApps[appSessionId] = createExternalSharedSession(Promise.resolve(enigmaDocObject), onWebSocketEvent2, {
+    appId
   });
-  return appSession;
 }
 
 // src/qix/qix-functions.ts
@@ -596,103 +689,30 @@ async function createSessionApp(ttlSeconds, workloadType) {
       workloadType
     });
   }
-  let alreadyClosed = false;
-  const listeners = /* @__PURE__ */ new Set();
-  const qixSessionAppSession = {
-    getDoc: () => sharedSession.docPromise,
-    onWebSocketEvent(fn) {
-      qixSessionAppSession._listeners.add(fn);
-      return () => {
-        qixSessionAppSession._listeners.delete(fn);
-      };
-    },
-    _listeners: listeners,
-    resume: async () => {
-      return await sharedSession.resume();
-    },
-    close(props) {
-      if (!alreadyClosed) {
-        alreadyClosed = true;
-        const defaultDelay = isBrowserEnvironment ? 5e3 : -1;
-        return sharedSession.removeClient(qixSessionAppSession, props?.websocketCloseDelay ?? defaultDelay);
-      }
-      return Promise.resolve();
-    }
-  };
-  return qixSessionAppSession;
+  return createAppSession(sharedSession);
 }
 function openAppSession(appIdOrProps) {
-  const appSessionProps = typeof appIdOrProps === "string" ? { appId: appIdOrProps, identity: void 0, hostConfig: void 0 } : appIdOrProps;
-  const appSessionId = toGlobalAppSessionId(appSessionProps);
-  const externalApp = externalApps[appSessionId];
-  if (externalApp) {
-    return getExternalSession(externalApp, appSessionProps);
-  }
+  const appSessionProps = typeof appIdOrProps === "string" ? { appId: appIdOrProps } : appIdOrProps;
   const sharedSession = getOrCreateSharedSession(appSessionProps);
-  const listeners = /* @__PURE__ */ new Set();
-  let alreadyClosed = false;
-  const qixAppSession = {
-    getDoc: () => sharedSession.docPromise,
-    onWebSocketEvent(fn) {
-      qixAppSession._listeners.add(fn);
-      return () => {
-        qixAppSession._listeners.delete(fn);
-      };
-    },
-    _listeners: listeners,
-    resume: async () => {
-      return await sharedSession.resume();
-    },
-    close(props) {
-      if (!alreadyClosed) {
-        alreadyClosed = true;
-        const defaultDelay = isBrowserEnvironment ? 5e3 : -1;
-        return sharedSession.removeClient(qixAppSession, props?.websocketCloseDelay ?? defaultDelay);
-      }
-      return Promise.resolve();
-    }
-  };
-  sharedSession.addClient(qixAppSession);
-  return qixAppSession;
-}
-function registerExternalAppSession(appId, enigmaDocObject) {
-  const appSessionId = toGlobalAppSessionId({ appId });
-  externalApps[appSessionId] = Promise.resolve(enigmaDocObject);
+  return createAppSession(sharedSession);
 }
 function useAppHook(react) {
   return (appId) => {
     const [app, setApp] = react.useState(void 0);
     react.useEffect(() => {
       const appSession = openAppSession(appId);
-      appSession.getDoc().then((x) => {
+      void appSession.getDoc().then((x) => {
         setApp(x);
       });
       return () => {
         if (appSession) {
-          appSession.close();
+          void appSession.close();
         }
       };
     }, [appId]);
     return app;
   };
 }
-function addInitialAppAction(openAppSessionProps, action) {
-  return addInitialSharedSessionCreationAction(openAppSessionProps, action);
-}
-function onWebSocketEvent(fn) {
-  return globalOnWebSocketEvent(fn);
-}
-function onCombinedWebSocketStateChange(fn) {
-  return globalOnStateChange(fn);
-}
-async function resumeSuspendedSessions() {
-  return resumeAll();
-}
-function resumeOnlyOnReattach(bool) {
-  resumeShouldRejectPromiseIfNotReattached(bool);
-}
-var externalApps = {};
-var isBrowserEnvironment = isBrowser();
 
 // src/qix/qix.ts
 var qix = {