qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/server/app-render/get-css-inlined-link-tags.js

@@ -8,15 +8,16 @@ Object.defineProperty(exports, "getLinkAndScriptTags", {
         return getLinkAndScriptTags;
     }
 });
-function getLinkAndScriptTags(clientReferenceManifest, filePath, injectedCSS, injectedScripts, collectNewImports) {
-    var _clientReferenceManifest_entryJSFiles;
+const _manifestssingleton = require("./manifests-singleton");
+function getLinkAndScriptTags(filePath, injectedCSS, injectedScripts, collectNewImports) {
     const filePathWithoutExt = filePath.replace(/\.[^.]+$/, '');
     const cssChunks = new Set();
     const jsChunks = new Set();
-    const entryCSSFiles = clientReferenceManifest.entryCSSFiles[filePathWithoutExt];
-    const entryJSFiles = ((_clientReferenceManifest_entryJSFiles = clientReferenceManifest.entryJSFiles) == null ? void 0 : _clientReferenceManifest_entryJSFiles[filePathWithoutExt]) ?? [];
-    if (entryCSSFiles) {
-        for (const css of entryCSSFiles){
+    const { entryCSSFiles, entryJSFiles } = (0, _manifestssingleton.getClientReferenceManifest)();
+    const cssFiles = entryCSSFiles[filePathWithoutExt];
+    const jsFiles = entryJSFiles == null ? void 0 : entryJSFiles[filePathWithoutExt];
+    if (cssFiles) {
+        for (const css of cssFiles){
             if (!injectedCSS.has(css.path)) {
                 if (collectNewImports) {
                     injectedCSS.add(css.path);
@@ -25,8 +26,8 @@ function getLinkAndScriptTags(clientReferenceManifest, filePath, injectedCSS, in
             }
         }
     }
-    if (entryJSFiles) {
-        for (const file of entryJSFiles){
+    if (jsFiles) {
+        for (const file of jsFiles){
             if (!injectedScripts.has(file)) {
                 if (collectNewImports) {
                     injectedScripts.add(file);

qalita/_frontend/node_modules/next/dist/server/app-render/get-layer-assets.js

@@ -15,7 +15,7 @@ const _encodeuripath = require("../../shared/lib/encode-uri-path");
 const _rendercssresource = require("./render-css-resource");
 function getLayerAssets({ ctx, layoutOrPagePath, injectedCSS: injectedCSSWithCurrentLayout, injectedJS: injectedJSWithCurrentLayout, injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout, preloadCallbacks }) {
     const { componentMod: { createElement } } = ctx;
-    const { styles: styleTags, scripts: scriptTags } = layoutOrPagePath ? (0, _getcssinlinedlinktags.getLinkAndScriptTags)(ctx.clientReferenceManifest, layoutOrPagePath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true) : {
+    const { styles: styleTags, scripts: scriptTags } = layoutOrPagePath ? (0, _getcssinlinedlinktags.getLinkAndScriptTags)(layoutOrPagePath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true) : {
         styles: [],
         scripts: []
     };

qalita/_frontend/node_modules/next/dist/server/app-render/manifests-singleton.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getClientReferenceManifest: null,
+    getServerActionsManifest: null,
+    getServerModuleMap: null,
+    selectWorkerForForwarding: null,
+    setManifestsSingleton: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getClientReferenceManifest: function() {
+        return getClientReferenceManifest;
+    },
+    getServerActionsManifest: function() {
+        return getServerActionsManifest;
+    },
+    getServerModuleMap: function() {
+        return getServerModuleMap;
+    },
+    selectWorkerForForwarding: function() {
+        return selectWorkerForForwarding;
+    },
+    setManifestsSingleton: function() {
+        return setManifestsSingleton;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
+const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
+const _workasyncstorageexternal = require("./work-async-storage.external");
+// This is a global singleton that is, among other things, also used to
+// encode/decode bound args of server function closures. This can't be using a
+// AsyncLocalStorage as it might happen at the module level.
+const MANIFESTS_SINGLETON = Symbol.for('next.server.manifests');
+const globalThisWithManifests = globalThis;
+function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute) {
+    const createMappingProxy = (prop)=>{
+        return new Proxy({}, {
+            get (_, id) {
+                const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+                if (workStore) {
+                    const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
+                    if (currentManifest == null ? void 0 : currentManifest[prop][id]) {
+                        return currentManifest[prop][id];
+                    }
+                    // In development, we also check all other manifests to see if the
+                    // module exists there. This is to support a scenario where React's
+                    // I/O tracking (dev-only) creates a connection from one page to
+                    // another through an emitted async I/O node that references client
+                    // components from the other page, e.g. in owner props.
+                    // TODO: Maybe we need to add a `debugBundlerConfig` option to React
+                    // to avoid this workaround. The current workaround has the
+                    // disadvantage that one might accidentally or intentionally share
+                    // client references across pages (e.g. by storing them in a global
+                    // variable), which would then only be caught in production.
+                    if (process.env.NODE_ENV !== 'production') {
+                        for (const [route, manifest] of clientReferenceManifestsPerRoute){
+                            if (route === workStore.route) {
+                                continue;
+                            }
+                            const entry = manifest[prop][id];
+                            if (entry !== undefined) {
+                                return entry;
+                            }
+                        }
+                    }
+                } else {
+                    // If there's no work store defined, we can assume that a client
+                    // reference manifest is needed during module evaluation, e.g. to
+                    // create a server function using a higher-order function. This
+                    // might also use client components which need to be serialized by
+                    // Flight, and therefore client references need to be resolvable. In
+                    // that case we search all page manifests to find the module.
+                    for (const manifest of clientReferenceManifestsPerRoute.values()){
+                        const entry = manifest[prop][id];
+                        if (entry !== undefined) {
+                            return entry;
+                        }
+                    }
+                }
+                return undefined;
+            }
+        });
+    };
+    const mappingProxies = new Map();
+    return new Proxy({}, {
+        get (_, prop) {
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            switch(prop){
+                case 'moduleLoading':
+                case 'entryCSSFiles':
+                case 'entryJSFiles':
+                    {
+                        if (!workStore) {
+                            throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot access "${prop}" without a work store.`), "__NEXT_ERROR_CODE", {
+                                value: "E952",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
+                        if (!currentManifest) {
+                            throw Object.defineProperty(new _invarianterror.InvariantError(`The client reference manifest for route "${workStore.route}" does not exist.`), "__NEXT_ERROR_CODE", {
+                                value: "E951",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        return currentManifest[prop];
+                    }
+                case 'clientModules':
+                case 'rscModuleMapping':
+                case 'edgeRscModuleMapping':
+                case 'ssrModuleMapping':
+                case 'edgeSSRModuleMapping':
+                    {
+                        let proxy = mappingProxies.get(prop);
+                        if (!proxy) {
+                            proxy = createMappingProxy(prop);
+                            mappingProxies.set(prop, proxy);
+                        }
+                        return proxy;
+                    }
+                default:
+                    {
+                        throw Object.defineProperty(new _invarianterror.InvariantError(`This is a proxied client reference manifest. The property "${String(prop)}" is not handled.`), "__NEXT_ERROR_CODE", {
+                            value: "E953",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+            }
+        }
+    });
+}
+/**
+ * This function creates a Flight-acceptable server module map proxy from our
+ * Server Reference Manifest similar to our client module map. This is because
+ * our manifest contains a lot of internal Next.js data that are relevant to the
+ * runtime, workers, etc. that React doesn't need to know.
+ */ function createServerModuleMap() {
+    return new Proxy({}, {
+        get: (_, id)=>{
+            var _getServerActionsManifest__id, _getServerActionsManifest_;
+            const workers = (_getServerActionsManifest_ = getServerActionsManifest()[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_getServerActionsManifest__id = _getServerActionsManifest_[id]) == null ? void 0 : _getServerActionsManifest__id.workers;
+            if (!workers) {
+                return undefined;
+            }
+            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+            let workerEntry;
+            if (workStore) {
+                workerEntry = workers[normalizeWorkerPageName(workStore.page)];
+            } else {
+                // If there's no work store defined, we can assume that a server
+                // module map is needed during module evaluation, e.g. to create a
+                // server action using a higher-order function. Therefore it should be
+                // safe to return any entry from the manifest that matches the action
+                // ID. They all refer to the same module ID, which must also exist in
+                // the current page bundle. TODO: This is currently not guaranteed in
+                // Turbopack, and needs to be fixed.
+                workerEntry = Object.values(workers).at(0);
+            }
+            if (!workerEntry) {
+                return undefined;
+            }
+            const { moduleId, async } = workerEntry;
+            return {
+                id: moduleId,
+                name: id,
+                chunks: [],
+                async
+            };
+        }
+    });
+}
+/**
+ * The flight entry loader keys actions by bundlePath. bundlePath corresponds
+ * with the relative path (including 'app') to the page entrypoint.
+ */ function normalizeWorkerPageName(pageName) {
+    if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
+        return pageName;
+    }
+    return 'app' + pageName;
+}
+/**
+ * Converts a bundlePath (relative path to the entrypoint) to a routable page
+ * name.
+ */ function denormalizeWorkerPageName(bundlePath) {
+    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
+}
+function selectWorkerForForwarding(actionId, pageName) {
+    var _serverActionsManifest__actionId;
+    const serverActionsManifest = getServerActionsManifest();
+    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
+    // There are no workers to handle this action, nothing to forward to.
+    if (!workers) {
+        return;
+    }
+    // If there is an entry for the current page, we don't need to forward.
+    if (workers[normalizeWorkerPageName(pageName)]) {
+        return;
+    }
+    // Otherwise, grab the first worker that has a handler for this action id.
+    return denormalizeWorkerPageName(Object.keys(workers)[0]);
+}
+function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest }) {
+    const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
+    if (existingSingleton) {
+        existingSingleton.clientReferenceManifestsPerRoute.set((0, _apppaths.normalizeAppPath)(page), clientReferenceManifest);
+        existingSingleton.serverActionsManifest = serverActionsManifest;
+    } else {
+        const clientReferenceManifestsPerRoute = new Map([
+            [
+                (0, _apppaths.normalizeAppPath)(page),
+                clientReferenceManifest
+            ]
+        ]);
+        const proxiedClientReferenceManifest = createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute);
+        globalThisWithManifests[MANIFESTS_SINGLETON] = {
+            clientReferenceManifestsPerRoute,
+            proxiedClientReferenceManifest,
+            serverActionsManifest,
+            serverModuleMap: createServerModuleMap()
+        };
+    }
+}
+function getManifestsSingleton() {
+    const manifestSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
+    if (!manifestSingleton) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('The manifests singleton was not initialized.'), "__NEXT_ERROR_CODE", {
+            value: "E950",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return manifestSingleton;
+}
+function getClientReferenceManifest() {
+    return getManifestsSingleton().proxiedClientReferenceManifest;
+}
+function getServerActionsManifest() {
+    return getManifestsSingleton().serverActionsManifest;
+}
+function getServerModuleMap() {
+    return getManifestsSingleton().serverModuleMap;
+}
+
+//# sourceMappingURL=manifests-singleton.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/prospective-render-utils.js

@@ -2,15 +2,32 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "printDebugThrownValueForProspectiveRender", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    Phase: null,
+    printDebugThrownValueForProspectiveRender: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Phase: function() {
+        return Phase;
+    },
+    printDebugThrownValueForProspectiveRender: function() {
         return printDebugThrownValueForProspectiveRender;
     }
 });
 const _createerrorhandler = require("./create-error-handler");
 const _reactlargeshellerror = require("./react-large-shell-error");
-function printDebugThrownValueForProspectiveRender(thrownValue, route) {
+var Phase = /*#__PURE__*/ function(Phase) {
+    Phase["ProspectiveRender"] = "the prospective render";
+    Phase["SegmentCollection"] = "segment collection";
+    return Phase;
+}({});
+function printDebugThrownValueForProspectiveRender(thrownValue, route, phase) {
     // We don't need to print well-known Next.js errors.
     if ((0, _createerrorhandler.getDigestForWellKnownError)(thrownValue)) {
         return;
@@ -27,10 +44,10 @@ function printDebugThrownValueForProspectiveRender(thrownValue, route) {
             const originalErrorStack = thrownValue.stack;
             const stackStart = originalErrorStack.indexOf('\n');
             if (stackStart > -1) {
-                const error = Object.defineProperty(new Error(`Route ${route} errored during the prospective render. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled.
+                const error = Object.defineProperty(new Error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled.
           
 Original Error: ${message}`), "__NEXT_ERROR_CODE", {
-                    value: "E362",
+                    value: "E949",
                     enumerable: false,
                     configurable: true
                 });
@@ -43,12 +60,12 @@ Original Error: ${message}`), "__NEXT_ERROR_CODE", {
         message = thrownValue;
     }
     if (message) {
-        console.error(`Route ${route} errored during the prospective render. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. No stack was provided.
+        console.error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. No stack was provided.
           
 Original Message: ${message}`);
         return;
     }
-    console.error(`Route ${route} errored during the prospective render. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. The thrown value is logged just following this message`);
+    console.error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. The thrown value is logged just following this message`);
     console.error(thrownValue);
     return;
 }

qalita/_frontend/node_modules/next/dist/server/app-render/staged-rendering.js

@@ -23,26 +23,36 @@ _export(exports, {
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 var RenderStage = /*#__PURE__*/ function(RenderStage) {
-    RenderStage[RenderStage["Static"] = 1] = "Static";
-    RenderStage[RenderStage["Runtime"] = 2] = "Runtime";
-    RenderStage[RenderStage["Dynamic"] = 3] = "Dynamic";
+    RenderStage[RenderStage["Before"] = 1] = "Before";
+    RenderStage[RenderStage["Static"] = 2] = "Static";
+    RenderStage[RenderStage["Runtime"] = 3] = "Runtime";
+    RenderStage[RenderStage["Dynamic"] = 4] = "Dynamic";
+    RenderStage[RenderStage["Abandoned"] = 5] = "Abandoned";
     return RenderStage;
 }({});
 class StagedRenderingController {
-    constructor(abortSignal = null){
+    constructor(abortSignal = null, hasRuntimePrefetch){
         this.abortSignal = abortSignal;
+        this.hasRuntimePrefetch = hasRuntimePrefetch;
         this.currentStage = 1;
+        this.staticInterruptReason = null;
+        this.runtimeInterruptReason = null;
+        this.staticStageEndTime = Infinity;
+        this.runtimeStageEndTime = Infinity;
+        this.runtimeStageListeners = [];
+        this.dynamicStageListeners = [];
         this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
         this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.mayAbandon = false;
         if (abortSignal) {
             abortSignal.addEventListener('abort', ()=>{
                 const { reason } = abortSignal;
-                if (this.currentStage < 2) {
+                if (this.currentStage < 3) {
                     this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
                     ;
                     this.runtimeStagePromise.reject(reason);
                 }
-                if (this.currentStage < 3) {
+                if (this.currentStage < 4 || this.currentStage === 5) {
                     this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
                     ;
                     this.dynamicStagePromise.reject(reason);
@@ -50,31 +60,167 @@ class StagedRenderingController {
             }, {
                 once: true
             });
+            this.mayAbandon = true;
+        }
+    }
+    onStage(stage, callback) {
+        if (this.currentStage >= stage) {
+            callback();
+        } else if (stage === 3) {
+            this.runtimeStageListeners.push(callback);
+        } else if (stage === 4) {
+            this.dynamicStageListeners.push(callback);
+        } else {
+            // This should never happen
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+                value: "E881",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    canSyncInterrupt() {
+        // If we haven't started the render yet, it can't be interrupted.
+        if (this.currentStage === 1) {
+            return false;
+        }
+        const boundaryStage = this.hasRuntimePrefetch ? 4 : 3;
+        return this.currentStage < boundaryStage;
+    }
+    syncInterruptCurrentStageWithReason(reason) {
+        if (this.currentStage === 1) {
+            return;
+        }
+        // If Sync IO occurs during the initial (abandonable) render, we'll retry it,
+        // so we want a slightly different flow.
+        // See the implementation of `abandonRenderImpl` for more explanation.
+        if (this.mayAbandon) {
+            return this.abandonRenderImpl();
+        }
+        // If we're in the final render, we cannot abandon it. We need to advance to the Dynamic stage
+        // and capture the interruption reason.
+        switch(this.currentStage){
+            case 2:
+                {
+                    this.staticInterruptReason = reason;
+                    this.advanceStage(4);
+                    return;
+                }
+            case 3:
+                {
+                    // We only error for Sync IO in the runtime stage if the route
+                    // is configured to use runtime prefetching.
+                    // We do this to reflect the fact that during a runtime prefetch,
+                    // Sync IO aborts aborts the render.
+                    // Note that `canSyncInterrupt` should prevent us from getting here at all
+                    // if runtime prefetching isn't enabled.
+                    if (this.hasRuntimePrefetch) {
+                        this.runtimeInterruptReason = reason;
+                        this.advanceStage(4);
+                    }
+                    return;
+                }
+            case 4:
+            case 5:
+            default:
+        }
+    }
+    getStaticInterruptReason() {
+        return this.staticInterruptReason;
+    }
+    getRuntimeInterruptReason() {
+        return this.runtimeInterruptReason;
+    }
+    getStaticStageEndTime() {
+        return this.staticStageEndTime;
+    }
+    getRuntimeStageEndTime() {
+        return this.runtimeStageEndTime;
+    }
+    abandonRender() {
+        if (!this.mayAbandon) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('`abandonRender` called on a stage controller that cannot be abandoned.'), "__NEXT_ERROR_CODE", {
+                value: "E938",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        this.abandonRenderImpl();
+    }
+    abandonRenderImpl() {
+        // In staged rendering, only the initial render is abandonable.
+        // We can abandon the initial render if
+        //   1. We notice a cache miss, and need to wait for caches to fill
+        //   2. A sync IO error occurs, and the render should be interrupted
+        //      (this might be a lazy intitialization of a module,
+        //       so we still want to restart in this case and see if it still occurs)
+        // In either case, we'll be doing another render after this one,
+        // so we only want to unblock the Runtime stage, not Dynamic, because
+        // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
+        const { currentStage } = this;
+        switch(currentStage){
+            case 2:
+                {
+                    this.currentStage = 5;
+                    this.resolveRuntimeStage();
+                    return;
+                }
+            case 3:
+                {
+                    this.currentStage = 5;
+                    return;
+                }
+            case 4:
+            case 1:
+            case 5:
+                break;
+            default:
+                {
+                    currentStage;
+                }
         }
     }
     advanceStage(stage) {
         // If we're already at the target stage or beyond, do nothing.
         // (this can happen e.g. if sync IO advanced us to the dynamic stage)
-        if (this.currentStage >= stage) {
+        if (stage <= this.currentStage) {
             return;
         }
+        let currentStage = this.currentStage;
         this.currentStage = stage;
-        // Note that we might be going directly from Static to Dynamic,
-        // so we need to resolve the runtime stage as well.
-        if (stage >= 2) {
-            this.runtimeStagePromise.resolve();
+        if (currentStage < 3 && stage >= 3) {
+            this.staticStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveRuntimeStage();
         }
-        if (stage >= 3) {
-            this.dynamicStagePromise.resolve();
+        if (currentStage < 4 && stage >= 4) {
+            this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveDynamicStage();
+            return;
+        }
+    }
+    /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
+        const runtimeListeners = this.runtimeStageListeners;
+        for(let i = 0; i < runtimeListeners.length; i++){
+            runtimeListeners[i]();
         }
+        runtimeListeners.length = 0;
+        this.runtimeStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
+        const dynamicListeners = this.dynamicStageListeners;
+        for(let i = 0; i < dynamicListeners.length; i++){
+            dynamicListeners[i]();
+        }
+        dynamicListeners.length = 0;
+        this.dynamicStagePromise.resolve();
     }
     getStagePromise(stage) {
         switch(stage){
-            case 2:
+            case 3:
                 {
                     return this.runtimeStagePromise.promise;
                 }
-            case 3:
+            case 4:
                 {
                     return this.dynamicStagePromise.promise;
                 }