@shapediver/viewer.session-engine.session-engine 2.11.0 → 2.12.0

package/src/implementation/SessionEngine.ts

@@ -4,7 +4,7 @@ import {
     latestVersion,
     validate,
     versions
-    } from '@shapediver/viewer.settings';
+} from '@shapediver/viewer.settings';
 import {
     create,
     isGBResponseError,
@@ -21,7 +21,7 @@ import {
     ShapeDiverResponseOutput,
     ShapeDiverSdk,
     ShapeDiverSdkConfigType
-    } from '@shapediver/sdk.geometry-api-sdk-v2';
+} from '@shapediver/sdk.geometry-api-sdk-v2';
 import {
     EventEngine,
     EVENTTYPE,
@@ -36,7 +36,7 @@ import {
     StateEngine,
     SystemInfo,
     UuidGenerator
-    } from '@shapediver/viewer.shared.services';
+} from '@shapediver/viewer.shared.services';
 import { Export } from './dto/Export';
 import { FileParameter } from './dto/FileParameter';
 import { IExport } from '../interfaces/dto/IExport';
@@ -45,13 +45,13 @@ import { IOutput } from '../interfaces/dto/IOutput';
 import { IParameter } from '../interfaces/dto/IParameter';
 import { ISessionEngine, ISettingsSections, PARAMETER_TYPE } from '../interfaces/ISessionEngine';
 import { ISessionTreeNode } from '../interfaces/ISessionTreeNode';
-import { ITaskEvent, TASK_TYPE } from '@shapediver/viewer.shared.types';
+import { IOutputEvent, ITaskEvent, TASK_TYPE } from '@shapediver/viewer.shared.types';
 import {
     ITree,
     ITreeNode,
     Tree,
     TreeNode
-    } from '@shapediver/viewer.shared.node-tree';
+} from '@shapediver/viewer.shared.node-tree';
 import { Output } from './dto/Output';
 import { OutputDelayException } from './OutputDelayException';
 import { OutputLoader, OutputLoaderTaskEventInfo } from './OutputLoader';
@@ -84,7 +84,7 @@ export class SessionEngine implements ISessionEngine {
     private readonly _ticket?: string;
     private readonly _uuidGenerator = UuidGenerator.instance;
 
-    #customizationProcess!: string;
+    #customizationProcess?: string;
     #parameterHistory: {
         [key: string]: {
             value: unknown,
@@ -267,7 +267,7 @@ export class SessionEngine implements ISessionEngine {
 
     // #endregion Public Accessors (25)
 
-    // #region Public Methods (25)
+    // #region Public Methods (27)
 
     public applySettings(response: ShapeDiverResponseDto, sections?: ISettingsSections) {
         sections = sections || {};
@@ -317,7 +317,7 @@ export class SessionEngine implements ISessionEngine {
                     if (sections.session.parameter.hidden) this.parameters[p].hidden = settings.session[p].hidden || false;
                 }
 
-                if (response.parameters && response.parameters[p]) {
+                if (response.parameters && response.parameters[p] && !((this.parameters[p] instanceof FileParameter) || this.parameters[p].type.startsWith('s'))) {
                     if (sections.session.parameter.value) this.parameters[p].value = response.parameters[p].defval !== undefined ? response.parameters[p].defval : this.parameters[p].value;
                 }
             }
@@ -409,6 +409,15 @@ export class SessionEngine implements ISessionEngine {
         return this.#parameterHistoryForward.length > 0;
     }
 
+    public cancelCustomization() {
+        if(this.#customizationProcess) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(this.#customizationProcess))
+                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(this.#customizationProcess), 1);
+        }
+        this.#customizationProcess = undefined;
+    }
+
     public async close(retry = false): Promise<void> {
         this.checkAvailability('close');
 
@@ -466,51 +475,14 @@ export class SessionEngine implements ISessionEngine {
                     fileParameterIds[parameterId] = await (<IFileParameter>this.parameters[parameterId]).upload();
 
                     // OPTION TO SKIP - PART 1a
-                    if (this.#customizationProcess !== customizationId) {
-                        for (const r in this._stateEngine.renderingEngines)
-                            if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                                this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-                        this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-
-                        const eventCancel1a: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                        this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-                        return new SessionTreeNode();
-                    } else if (this._closed === true) {
-                        for (const r in this._stateEngine.renderingEngines)
-                            if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                                this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-                        this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-
-                        const eventCancel1a: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                        this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-                        return new SessionTreeNode();
-                    }
+                    const cancelResult = this.cancelProcess(customizationId, eventId, TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                    if (cancelResult) return cancelResult;
                 }
             }
 
             // OPTION TO SKIP - PART 1b
-            if (this.#customizationProcess !== customizationId) {
-                for (const r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-                const eventCancel1b: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1b);
-                this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-                return new SessionTreeNode();
-            } else if (this._closed === true) {
-                for (const r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-                this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-
-                const eventCancel1b: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1b);
-                return new SessionTreeNode();
-            }
+            const cancelResult = this.cancelProcess(customizationId, eventId, TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+            if (cancelResult) return cancelResult;
 
             // assign the uploaded parameters
             for (const parameterId in fileParameterIds)
@@ -539,6 +511,8 @@ export class SessionEngine implements ISessionEngine {
             const eventRequest: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.1, data: { sessionId: this.id }, status: 'Sending customization request' };
             this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
 
+            const oldOutputVersions = this._outputLoader.getCurrentOutputVersions();
+
             const newNode = await this.customizeInternal(() => this.#customizationProcess !== customizationId, {
                 eventId,
                 type: TASK_TYPE.SESSION_CUSTOMIZATION,
@@ -549,29 +523,32 @@ export class SessionEngine implements ISessionEngine {
                 data: { sessionId: this.id }
             });
 
+            // OPTION TO SKIP - PART 2
+            const cancelResult2 = this.cancelProcess(customizationId, eventId, TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+            if (cancelResult2) return cancelResult2;
+
+            const newOutputVersions = this._outputLoader.getCurrentOutputVersions();
+
             const eventSceneUpdate: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.9, data: { sessionId: this.id }, status: 'Updating scene' };
             this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
 
-            // OPTION TO SKIP - PART 2
-            if (this.#customizationProcess !== customizationId) {
-                for (const r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-                const eventCancel2: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel2);
-                this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-                return newNode;
-            } else if ((this._closed as boolean) === true) { // I get a TS warning here that the type of _closed is "false", I think TS doesn't get that there is a promise inbetween
-                for (const r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
+            // call the update callbacks
+            if (waitForViewportUpdate === false) {
+                for (const outputId in this.outputs) {
+                    if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                        this._eventEngine.emitEvent(EVENTTYPE.OUTPUT.OUTPUT_UPDATED, <IOutputEvent>{
+                            outputId: outputId,
+                            outputVersion: newOutputVersions[outputId],
+                            newNode: newNode.children.find(c => c.name === outputId)!,
+                            oldNode: oldNode.children.find(c => c.name === outputId)!
+                        });
+                    }
+                }
 
-                this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
+                await this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
 
-                const eventCancel2: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel2);
-                return new SessionTreeNode();
+                const cancelResult = this.cancelProcess(customizationId, eventId, TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                if (cancelResult) return cancelResult;
             }
 
             // if this is not a call by the goBack or goForward functions, add the parameter values to the history and delete the forward history
@@ -617,20 +594,37 @@ export class SessionEngine implements ISessionEngine {
             this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
 
             // update the viewports
-            if (waitForViewportUpdate)
+            if (waitForViewportUpdate) {
                 for (const r in this._stateEngine.renderingEngines)
                     if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
                         this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
 
-            // call the update callback function on the session
-            if (this._updateCallback) this._updateCallback(newNode, oldNode);
+                        
+                for (const outputId in this.outputs) {
+                    if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                        this._eventEngine.emitEvent(EVENTTYPE.OUTPUT.OUTPUT_UPDATED, <IOutputEvent>{
+                            outputId: outputId,
+                            outputVersion: newOutputVersions[outputId],
+                            newNode: newNode.children.find(c => c.name === outputId)!,
+                            oldNode: oldNode.children.find(c => c.name === outputId)!
+                        });
+                    }
+                }
 
-            // call the update callback functions on the outputs
-            for (const outputId in this.outputs)
-                this.outputs[outputId].triggerUpdateCallback(
-                    newNode.children.find(c => c.name === outputId)!,
-                    oldNode.children.find(c => c.name === outputId)!
-                );
+                // call the update callbacks
+                await this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+
+                const cancelResult = this.cancelProcess(customizationId, eventId, TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                if (cancelResult) return cancelResult;
+            }
+
+            if (!waitForViewportUpdate) {
+                setTimeout(() => {
+                    for (const r in this._stateEngine.renderingEngines)
+                        if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
+                            this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
+                }, 0);
+            }
 
             return this.node;
         } catch (e) {
@@ -645,7 +639,7 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
-    public async customizeParallel(parameterValues: { [key: string]: string }): Promise<ITreeNode> {
+    public async customizeParallel(parameterValues: { [key: string]: string }, loadOutputs = true): Promise<ISessionTreeNode | ShapeDiverResponseDto> {
         const eventId = this._uuidGenerator.create();
 
         const eventStart: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0, data: { sessionId: this.id }, status: 'Customizing session' };
@@ -659,7 +653,7 @@ export class SessionEngine implements ISessionEngine {
         for (const parameterId in this.parameters)
             parameterSet[parameterId] = parameterValues[parameterId] !== undefined ? (' ' + parameterValues[parameterId]).slice(1) : this.parameters[parameterId].stringify();
 
-        const newNode = await this.customizeSession(parameterSet, () => false, {
+        const result = await this.customizeSession(parameterSet, () => false, {
             eventId,
             type: TASK_TYPE.SESSION_CUSTOMIZATION,
             progressRange: {
@@ -667,12 +661,14 @@ export class SessionEngine implements ISessionEngine {
                 max: 1
             },
             data: { sessionId: this.id }
-        }, true);
-        newNode.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
+        }, true, loadOutputs);
+
+        if (result instanceof SessionTreeNode)
+            result.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
 
         const eventEnd: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customized' };
         this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
-        return newNode;
+        return result;
     }
 
     public async goBack(): Promise<ITreeNode> {
@@ -772,6 +768,63 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
+    public async loadCachedOutputsParallel(outputMapping: { [key: string]: string }, taskEventInfo?: OutputLoaderTaskEventInfo, retry = false): Promise<{ [key: string]: ITreeNode | undefined }> {
+        this.checkAvailability();
+        // if there is already task event info, use it
+        // this happens after a retry
+        const eventId = taskEventInfo ? taskEventInfo.eventId : this._uuidGenerator.create();
+        const eventType = taskEventInfo ? taskEventInfo.type : TASK_TYPE.SESSION_OUTPUTS_LOADING;
+        const eventData = taskEventInfo ? taskEventInfo.data : { sessionId: this.id };
+
+        taskEventInfo = taskEventInfo ? taskEventInfo : {
+            eventId,
+            type: eventType,
+            progressRange: {
+                min: 0,
+                max: 1
+            },
+            data: eventData
+        };
+
+        try {
+            // send start event if this function was called initially
+            if (!taskEventInfo) {
+                const eventStart: ITaskEvent = { type: eventType, id: eventId, progress: 0, data: eventData, status: 'Loading cached outputs' };
+                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
+            }
+
+            // get the cached outputs
+            const responseDto = await this._sdk.output.getCache(this._sessionId!, outputMapping);
+
+            // create atomic output api objects for them
+            const outputs: {
+                [key: string]: IOutput;
+            } = {};
+            for (const outputId in responseDto.outputs) {
+                responseDto.outputs[outputId].id = outputId;
+                outputs[outputId] = new Output(<ShapeDiverResponseOutput>responseDto.outputs[outputId], this);
+            }
+
+            // process the output data
+            const node = await this._outputLoader.loadOutputs(this._responseDto!.model?.name || 'model', outputs, {}, taskEventInfo, false);
+
+            // send the end event once done
+            const eventEnd: ITaskEvent = { type: eventType, id: eventId, progress: 1, data: eventData, status: 'Loaded cached outputs' };
+            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
+
+            // create a mapping with a dictionary for the id of the outputs
+            const outputNodeMapping: { [key: string]: ITreeNode | undefined } = {};
+            for (const outputId in outputMapping)
+                outputNodeMapping[outputId] = node.children.find(n => n.name === outputId);
+
+            return outputNodeMapping;
+        }
+        catch (e) {
+            await this.handleError(e, retry);
+            return await this.loadCachedOutputsParallel(outputMapping, taskEventInfo, true);
+        }
+    }
+
     /**
      * Load the outputs and return the scene graph node of the result.
      * In case the outputs have a delay property, another customization request with the parameter set is sent.
@@ -788,15 +841,8 @@ export class SessionEngine implements ISessionEngine {
         try {
             const node = await this._outputLoader.loadOutputs(this._responseDto!.model?.name || 'model', o, of, taskEventInfo);
             node.data.push(new SessionData(this._responseDto!));
-
             if (cancelRequest()) return node;
-
-            if (this._automaticSceneUpdate) this.removeFromSceneTree(this._node);
-            this._node = node;
-            if (this._automaticSceneUpdate && this._closed === false) this.addToSceneTree(this._node);
-
-            this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
-
+            node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
             return node;
         }
         catch (e) {
@@ -1139,6 +1185,8 @@ export class SessionEngine implements ISessionEngine {
         const eventRequest: ITaskEvent = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 0.1 + taskEventInfo.progressRange.min : 0.1, data: eventData, status: 'Loading outputs' };
         this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
 
+        const oldOutputVersions = this._outputLoader.getCurrentOutputVersions();
+
         const newNode = await this.loadOutputs(() => this.#customizationProcess !== customizationId, {
             eventId,
             type: eventType,
@@ -1149,29 +1197,33 @@ export class SessionEngine implements ISessionEngine {
             data: eventData
         });
 
+        const newOutputVersions = this._outputLoader.getCurrentOutputVersions();
+
         const eventSceneUpdate: ITaskEvent = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 0.9 + taskEventInfo.progressRange.min : 0.9, data: eventData, status: 'Updating scene' };
         this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
 
         // OPTION TO SKIP - PART 1
-        if (this.#customizationProcess !== customizationId) {
-            for (const r in this._stateEngine.renderingEngines)
-                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-            const eventCancel1: ITaskEvent = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, data: eventData, status: 'Output updating was exceeded by other customization request' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1);
-            this._logger.debug(`Session(${this.id}).updateOutputs: Output updating was exceeded by other request.`);
-            return newNode;
-        } else if (this._closed === true) {
-            for (const r in this._stateEngine.renderingEngines)
-                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-
-            this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
+        const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+        if (cancelResult) return cancelResult;
+
+        // call the update callbacks
+        if (waitForViewportUpdate === false) {            
+            for (const outputId in this.outputs) {
+                if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                    this._eventEngine.emitEvent(EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                        outputId: outputId,
+                        outputVersion: newOutputVersions[outputId],
+                        newNode: newNode.children.find(c => c.name === outputId)!,
+                        oldNode: oldNode.children.find(c => c.name === outputId)!
+                    });
+                }
+            }
+            
+            await this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
 
-            const eventCancel1a: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-            return new SessionTreeNode();
+            // OPTION TO SKIP - PART 2
+            const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+            if (cancelResult) return cancelResult;
         }
 
         if (this.automaticSceneUpdate) this.removeFromSceneTree(this.node);
@@ -1207,20 +1259,28 @@ export class SessionEngine implements ISessionEngine {
         }
 
         // update the viewports
-        if (waitForViewportUpdate)
+        if (waitForViewportUpdate) {
             for (const r in this._stateEngine.renderingEngines)
                 if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
                     this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).updateOutputs`);
 
-        // call the update callback function on the session
-        if (this._updateCallback) this._updateCallback(newNode, oldNode);
+            for (const outputId in this.outputs) {
+                if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                    this._eventEngine.emitEvent(EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                        outputId: outputId,
+                        outputVersion: newOutputVersions[outputId],
+                        newNode: newNode.children.find(c => c.name === outputId)!,
+                        oldNode: oldNode.children.find(c => c.name === outputId)!
+                    });
+                }
+            }
 
-        // call the update callback functions on the outputs
-        for (const outputId in this.outputs)
-            this.outputs[outputId].triggerUpdateCallback(
-                newNode.children.find(c => c.name === outputId)!,
-                oldNode.children.find(c => c.name === outputId)!
-            );
+            await this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+
+            // OPTION TO SKIP - PART 3
+            const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+            if (cancelResult) return cancelResult;
+        }
 
         return this.node;
     }
@@ -1258,9 +1318,9 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
-    // #endregion Public Methods (25)
+    // #endregion Public Methods (27)
 
-    // #region Private Methods (11)
+    // #region Private Methods (13)
 
     private _saveSessionSettings() {
         const parameters = this.parameters;
@@ -1337,6 +1397,35 @@ export class SessionEngine implements ISessionEngine {
         this._sceneTree.root.updateVersion();
     }
 
+    private cancelProcess(customizationId: string, eventId: string, eventType: TASK_TYPE, eventProgress: number, eventData: unknown, newNode: ITreeNode = new SessionTreeNode()): ITreeNode | undefined {
+        if (this.#customizationProcess !== customizationId) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
+                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
+
+            const eventCancel: ITaskEvent = {
+                type: eventType,
+                id: eventId,
+                progress: eventProgress,
+                data: eventData,
+                status: 'The request was exceeded by another customization request'
+            };
+            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
+            this._logger.debug(`Session(${this.id}).cancelProcess: The request was was exceeded by another request.`);
+            return newNode;
+        } else if ((this._closed as boolean) === true) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
+                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
+
+            this._logger.debug(`Session(${this.id}).cancelProcess: The session was closed during the request.`);
+
+            const eventCancel: ITaskEvent = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'The session was closed during the request.' };
+            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
+            return new SessionTreeNode();
+        }
+    }
+
     private checkAvailability(action?: string, checkForModelId = false) {
         if (!this._responseDto)
             throw new ShapeDiverViewerSessionError('Session.checkAvailability: responseDto not available.');
@@ -1385,22 +1474,33 @@ export class SessionEngine implements ISessionEngine {
     }
 
     private async customizeInternal(cancelRequest: () => boolean, taskEventInfo: OutputLoaderTaskEventInfo): Promise<ISessionTreeNode> {
-        return this.customizeSession(this._parameterValues, cancelRequest, taskEventInfo);
+        return this.customizeSession(this._parameterValues, cancelRequest, taskEventInfo) as Promise<ISessionTreeNode>;
     }
 
-    private async customizeSession(parameters: { [key: string]: string }, cancelRequest: () => boolean, taskEventInfo: OutputLoaderTaskEventInfo, parallel = false, retry = false): Promise<ISessionTreeNode> {
+    private async customizeSession(parameters: { [key: string]: string }, cancelRequest: () => boolean, taskEventInfo: OutputLoaderTaskEventInfo, parallel = false, loadOutputs = true, retry = false): Promise<ISessionTreeNode | ShapeDiverResponseDto> {
         this.checkAvailability('customize');
         try {
             this._performanceEvaluator.startSection('sessionResponse');
             const responseDto = await this._sdk.utils.submitAndWaitForCustomization(this._sdk, this._sessionId!, parameters);
             this._performanceEvaluator.endSection('sessionResponse');
-            if (cancelRequest()) return new SessionTreeNode();
-            if (parallel === false) this.updateResponseDto(responseDto);
-            return parallel === false ? this.loadOutputs(cancelRequest, taskEventInfo) : this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
+            if (loadOutputs === true) {
+                if (cancelRequest()) return new SessionTreeNode();
+                if (parallel === true) {
+                    // special case, we load the outputs put don't add them to the scene
+                    return this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
+                } else {
+                    // default case, we load the outputs and return the nodes
+                    this.updateResponseDto(responseDto);
+                    return this.loadOutputs(cancelRequest, taskEventInfo);
+                }
+            } else {
+                // special case, we don't load the outputs and only return the responseDto
+                return responseDto;
+            }
         } catch (e) {
             await this.handleError(e, retry);
             if (cancelRequest()) return new SessionTreeNode();
-            return await this.customizeSession(parameters, cancelRequest, taskEventInfo, parallel, true);
+            return await this.customizeSession(parameters, cancelRequest, taskEventInfo, parallel, loadOutputs, true);
         }
     }
 
@@ -1585,5 +1685,24 @@ export class SessionEngine implements ISessionEngine {
         }
     }
 
-    // #endregion Private Methods (11)
+    private async waitForUpdateCallbacks(newOutputVersions: { [key: string]: string }, oldOutputVersions: { [key: string]: string }, newNode: ITreeNode, oldNode: ITreeNode) {
+        // call the update callback function on the session
+        if (this._updateCallback) await Promise.resolve(this._updateCallback(newNode, oldNode));
+
+        const promises = [];
+        // call the update callback functions on the outputs
+        for (const outputId in this.outputs) {
+            if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                promises.push(
+                    this.outputs[outputId].triggerUpdateCallback(
+                        newNode.children.find(c => c.name === outputId)!,
+                        oldNode.children.find(c => c.name === outputId)!
+                    )
+                );
+            }
+        }
+        await Promise.all(promises);
+    }
+
+    // #endregion Private Methods (13)
 }

package/src/implementation/dto/Output.ts

@@ -173,8 +173,8 @@ export class Output implements IOutput {
 
   // #region Public Methods (4)
 
-  public triggerUpdateCallback(newNode?: TreeNode, oldNode?: TreeNode) {
-    if (this.#updateCallback) this.#updateCallback(newNode, oldNode);
+  public async triggerUpdateCallback(newNode?: TreeNode, oldNode?: TreeNode) {
+    if (this.#updateCallback) await Promise.resolve(this.#updateCallback(newNode, oldNode));
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/src/interfaces/ISessionEngine.ts

@@ -130,11 +130,12 @@ export interface ISessionEngine {
   canGoBack(): boolean;
   canGoForward(): boolean;
   close(): Promise<void>;
-  customize(force: boolean, waitForViewportUpdate?: boolean): Promise<ITreeNode>;
-  customizeParallel(parameterValues: { [key: string]: string }): Promise<ITreeNode>;
+  customize(force: boolean, waitForViewportUpdate?: boolean):Promise<ITreeNode | ShapeDiverResponseDto>;
+  customizeParallel(parameterValues: { [key: string]: string }, loadOutputs: boolean): Promise<ITreeNode | ShapeDiverResponseDto>;
   goBack(): Promise<ITreeNode>;
   goForward(): Promise<ITreeNode>;
   init(parameterValues?: { [key: string]: string; }): Promise<void>;
+  loadCachedOutputsParallel(outputMapping: { [key: string]: string }, taskEventInfo?: OutputLoaderTaskEventInfo, retry?: boolean): Promise<{ [key: string]: ITreeNode | undefined }>;
   loadOutputs(cancelRequest: () => boolean, taskEventInfo: OutputLoaderTaskEventInfo): Promise<ITreeNode>;
   loadOutputsParallel(responseDto: ShapeDiverResponseDto, cancelRequest: () => boolean, taskEventInfo: OutputLoaderTaskEventInfo): Promise<ITreeNode>;
   requestExport(exportId: string, parameters: ShapeDiverRequestCustomization, maxWaitTime: number): Promise<ShapeDiverResponseExport>;