Initial commit

frontend/webapp/node_modules/next/dist/server/ReactDOMServerPages.d.ts

@@ -0,0 +1 @@
+export * from 'react-dom/server.edge'

frontend/webapp/node_modules/next/dist/server/ReactDOMServerPages.js

@@ -0,0 +1,15 @@
+"use strict";
+let ReactDOMServer;
+try {
+    ReactDOMServer = require('react-dom/server.edge');
+} catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND' && error.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+        throw error;
+    }
+    // In React versions without react-dom/server.edge, the browser build works in Node.js.
+    // The Node.js build does not support renderToReadableStream.
+    ReactDOMServer = require('react-dom/server.browser');
+}
+module.exports = ReactDOMServer;
+
+//# sourceMappingURL=ReactDOMServerPages.js.map

frontend/webapp/node_modules/next/dist/server/ReactDOMServerPages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/server/ReactDOMServerPages.js"],"sourcesContent":["let ReactDOMServer\n\ntry {\n  ReactDOMServer = require('react-dom/server.edge')\n} catch (error) {\n  if (\n    error.code !== 'MODULE_NOT_FOUND' &&\n    error.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED'\n  ) {\n    throw error\n  }\n  // In React versions without react-dom/server.edge, the browser build works in Node.js.\n  // The Node.js build does not support renderToReadableStream.\n  ReactDOMServer = require('react-dom/server.browser')\n}\n\nmodule.exports = ReactDOMServer\n"],"names":["ReactDOMServer","require","error","code","module","exports"],"mappings":";AAAA,IAAIA;AAEJ,IAAI;IACFA,iBAAiBC,QAAQ;AAC3B,EAAE,OAAOC,OAAO;IACd,IACEA,MAAMC,IAAI,KAAK,sBACfD,MAAMC,IAAI,KAAK,iCACf;QACA,MAAMD;IACR;IACA,uFAAuF;IACvF,6DAA6D;IAC7DF,iBAAiBC,QAAQ;AAC3B;AAEAG,OAAOC,OAAO,GAAGL"}

frontend/webapp/node_modules/next/dist/server/accept-header.d.ts

@@ -0,0 +1 @@
+export declare function acceptLanguage(header?: string, preferences?: readonly string[]): string;

frontend/webapp/node_modules/next/dist/server/accept-header.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "acceptLanguage", {
+    enumerable: true,
+    get: function() {
+        return acceptLanguage;
+    }
+});
+function parse(raw, preferences, options) {
+    const lowers = new Map();
+    const header = raw.replace(/[ \t]/g, '');
+    if (preferences) {
+        let pos = 0;
+        for (const preference of preferences){
+            const lower = preference.toLowerCase();
+            lowers.set(lower, {
+                orig: preference,
+                pos: pos++
+            });
+            if (options.prefixMatch) {
+                const parts = lower.split('-');
+                while(parts.pop(), parts.length > 0){
+                    const joined = parts.join('-');
+                    if (!lowers.has(joined)) {
+                        lowers.set(joined, {
+                            orig: preference,
+                            pos: pos++
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const parts = header.split(',');
+    const selections = [];
+    const map = new Set();
+    for(let i = 0; i < parts.length; ++i){
+        const part = parts[i];
+        if (!part) {
+            continue;
+        }
+        const params = part.split(';');
+        if (params.length > 2) {
+            throw Object.defineProperty(new Error(`Invalid ${options.type} header`), "__NEXT_ERROR_CODE", {
+                value: "E77",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let token = params[0].toLowerCase();
+        if (!token) {
+            throw Object.defineProperty(new Error(`Invalid ${options.type} header`), "__NEXT_ERROR_CODE", {
+                value: "E77",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const selection = {
+            token,
+            pos: i,
+            q: 1
+        };
+        if (preferences && lowers.has(token)) {
+            selection.pref = lowers.get(token).pos;
+        }
+        map.add(selection.token);
+        if (params.length === 2) {
+            const q = params[1];
+            const [key, value] = q.split('=');
+            if (!value || key !== 'q' && key !== 'Q') {
+                throw Object.defineProperty(new Error(`Invalid ${options.type} header`), "__NEXT_ERROR_CODE", {
+                    value: "E77",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            const score = parseFloat(value);
+            if (score === 0) {
+                continue;
+            }
+            if (Number.isFinite(score) && score <= 1 && score >= 0.001) {
+                selection.q = score;
+            }
+        }
+        selections.push(selection);
+    }
+    selections.sort((a, b)=>{
+        if (b.q !== a.q) {
+            return b.q - a.q;
+        }
+        if (b.pref !== a.pref) {
+            if (a.pref === undefined) {
+                return 1;
+            }
+            if (b.pref === undefined) {
+                return -1;
+            }
+            return a.pref - b.pref;
+        }
+        return a.pos - b.pos;
+    });
+    const values = selections.map((selection)=>selection.token);
+    if (!preferences || !preferences.length) {
+        return values;
+    }
+    const preferred = [];
+    for (const selection of values){
+        if (selection === '*') {
+            for (const [preference, value] of lowers){
+                if (!map.has(preference)) {
+                    preferred.push(value.orig);
+                }
+            }
+        } else {
+            const lower = selection.toLowerCase();
+            if (lowers.has(lower)) {
+                preferred.push(lowers.get(lower).orig);
+            }
+        }
+    }
+    return preferred;
+}
+function acceptLanguage(header = '', preferences) {
+    return parse(header, preferences, {
+        type: 'accept-language',
+        prefixMatch: true
+    })[0] || '';
+}
+
+//# sourceMappingURL=accept-header.js.map

frontend/webapp/node_modules/next/dist/server/after/after-context.d.ts

@@ -0,0 +1,21 @@
+import type { RequestLifecycleOpts } from '../base-server';
+import type { AfterTask } from './after';
+export type AfterContextOpts = {
+    waitUntil: RequestLifecycleOpts['waitUntil'] | undefined;
+    onClose: RequestLifecycleOpts['onClose'];
+    onTaskError: RequestLifecycleOpts['onAfterTaskError'] | undefined;
+};
+export declare class AfterContext {
+    private waitUntil;
+    private onClose;
+    private onTaskError;
+    private runCallbacksOnClosePromise;
+    private callbackQueue;
+    private workUnitStores;
+    constructor({ waitUntil, onClose, onTaskError }: AfterContextOpts);
+    after(task: AfterTask): void;
+    private addCallback;
+    private runCallbacksOnClose;
+    private runCallbacks;
+    private reportTaskError;
+}

frontend/webapp/node_modules/next/dist/server/after/after-context.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AfterContext", {
+    enumerable: true,
+    get: function() {
+        return AfterContext;
+    }
+});
+const _pqueue = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/p-queue"));
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _isthenable = require("../../shared/lib/is-thenable");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _revalidationutils = require("../revalidation-utils");
+const _asynclocalstorage = require("../app-render/async-local-storage");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _aftertaskasyncstorageexternal = require("../app-render/after-task-async-storage.external");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class AfterContext {
+    constructor({ waitUntil, onClose, onTaskError }){
+        this.workUnitStores = new Set();
+        this.waitUntil = waitUntil;
+        this.onClose = onClose;
+        this.onTaskError = onTaskError;
+        this.callbackQueue = new _pqueue.default();
+        this.callbackQueue.pause();
+    }
+    after(task) {
+        if ((0, _isthenable.isThenable)(task)) {
+            if (!this.waitUntil) {
+                errorWaitUntilNotAvailable();
+            }
+            this.waitUntil(task.catch((error)=>this.reportTaskError('promise', error)));
+        } else if (typeof task === 'function') {
+            // TODO(after): implement tracing
+            this.addCallback(task);
+        } else {
+            throw Object.defineProperty(new Error('`after()`: Argument must be a promise or a function'), "__NEXT_ERROR_CODE", {
+                value: "E50",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    addCallback(callback) {
+        // if something is wrong, throw synchronously, bubbling up to the `after` callsite.
+        if (!this.waitUntil) {
+            errorWaitUntilNotAvailable();
+        }
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (workUnitStore) {
+            this.workUnitStores.add(workUnitStore);
+        }
+        const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
+        // This is used for checking if request APIs can be called inside `after`.
+        // Note that we need to check the phase in which the *topmost* `after` was called (which should be "action"),
+        // not the current phase (which might be "after" if we're in a nested after).
+        // Otherwise, we might allow `after(() => headers())`, but not `after(() => after(() => headers()))`.
+        const rootTaskSpawnPhase = afterTaskStore ? afterTaskStore.rootTaskSpawnPhase // nested after
+         : workUnitStore == null ? void 0 : workUnitStore.phase // topmost after
+        ;
+        // this should only happen once.
+        if (!this.runCallbacksOnClosePromise) {
+            this.runCallbacksOnClosePromise = this.runCallbacksOnClose();
+            this.waitUntil(this.runCallbacksOnClosePromise);
+        }
+        // Bind the callback to the current execution context (i.e. preserve all currently available ALS-es).
+        // We do this because we want all of these to be equivalent in every regard except timing:
+        //   after(() => x())
+        //   after(x())
+        //   await x()
+        const wrappedCallback = (0, _asynclocalstorage.bindSnapshot)(async ()=>{
+            try {
+                await _aftertaskasyncstorageexternal.afterTaskAsyncStorage.run({
+                    rootTaskSpawnPhase
+                }, ()=>callback());
+            } catch (error) {
+                this.reportTaskError('function', error);
+            }
+        });
+        this.callbackQueue.add(wrappedCallback);
+    }
+    async runCallbacksOnClose() {
+        await new Promise((resolve)=>this.onClose(resolve));
+        return this.runCallbacks();
+    }
+    async runCallbacks() {
+        if (this.callbackQueue.size === 0) return;
+        for (const workUnitStore of this.workUnitStores){
+            workUnitStore.phase = 'after';
+        }
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        if (!workStore) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in AfterContext.runCallbacks'), "__NEXT_ERROR_CODE", {
+                value: "E547",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return (0, _revalidationutils.withExecuteRevalidates)(workStore, ()=>{
+            this.callbackQueue.start();
+            return this.callbackQueue.onIdle();
+        });
+    }
+    reportTaskError(taskKind, error) {
+        // TODO(after): this is fine for now, but will need better intergration with our error reporting.
+        // TODO(after): should we log this if we have a onTaskError callback?
+        console.error(taskKind === 'promise' ? `A promise passed to \`after()\` rejected:` : `An error occurred in a function passed to \`after()\`:`, error);
+        if (this.onTaskError) {
+            // this is very defensive, but we really don't want anything to blow up in an error handler
+            try {
+                this.onTaskError == null ? void 0 : this.onTaskError.call(this, error);
+            } catch (handlerError) {
+                console.error(Object.defineProperty(new _invarianterror.InvariantError('`onTaskError` threw while handling an error thrown from an `after` task', {
+                    cause: handlerError
+                }), "__NEXT_ERROR_CODE", {
+                    value: "E569",
+                    enumerable: false,
+                    configurable: true
+                }));
+            }
+        }
+    }
+}
+function errorWaitUntilNotAvailable() {
+    throw Object.defineProperty(new Error('`after()` will not work correctly, because `waitUntil` is not available in the current environment.'), "__NEXT_ERROR_CODE", {
+        value: "E91",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=after-context.js.map

frontend/webapp/node_modules/next/dist/server/after/after.d.ts

@@ -0,0 +1,6 @@
+export type AfterTask<T = unknown> = Promise<T> | AfterCallback<T>;
+export type AfterCallback<T = unknown> = () => T | Promise<T>;
+/**
+ * This function allows you to schedule callbacks to be executed after the current request finishes.
+ */
+export declare function after<T>(task: AfterTask<T>): void;

frontend/webapp/node_modules/next/dist/server/after/after.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "after", {
+    enumerable: true,
+    get: function() {
+        return after;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+function after(task) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        // TODO(after): the linked docs page talks about *dynamic* APIs, which after soon won't be anymore
+        throw Object.defineProperty(new Error('`after` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context'), "__NEXT_ERROR_CODE", {
+            value: "E468",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { afterContext } = workStore;
+    return afterContext.after(task);
+}
+
+//# sourceMappingURL=after.js.map

frontend/webapp/node_modules/next/dist/server/after/after.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/after/after.ts"],"sourcesContent":["import { workAsyncStorage } from '../app-render/work-async-storage.external'\n\nexport type AfterTask<T = unknown> = Promise<T> | AfterCallback<T>\nexport type AfterCallback<T = unknown> = () => T | Promise<T>\n\n/**\n * This function allows you to schedule callbacks to be executed after the current request finishes.\n */\nexport function after<T>(task: AfterTask<T>): void {\n  const workStore = workAsyncStorage.getStore()\n\n  if (!workStore) {\n    // TODO(after): the linked docs page talks about *dynamic* APIs, which after soon won't be anymore\n    throw new Error(\n      '`after` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context'\n    )\n  }\n\n  const { afterContext } = workStore\n  return afterContext.after(task)\n}\n"],"names":["after","task","workStore","workAsyncStorage","getStore","Error","afterContext"],"mappings":";;;;+BAQgBA;;;eAAAA;;;0CARiB;AAQ1B,SAASA,MAASC,IAAkB;IACzC,MAAMC,YAAYC,0CAAgB,CAACC,QAAQ;IAE3C,IAAI,CAACF,WAAW;QACd,kGAAkG;QAClG,MAAM,qBAEL,CAFK,IAAIG,MACR,2HADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,MAAM,EAAEC,YAAY,EAAE,GAAGJ;IACzB,OAAOI,aAAaN,KAAK,CAACC;AAC5B"}

frontend/webapp/node_modules/next/dist/server/after/awaiter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Provides a `waitUntil` implementation which gathers promises to be awaited later (via {@link AwaiterMulti.awaiting}).
+ * Unlike a simple `Promise.all`, {@link AwaiterMulti} works recursively --
+ * if a promise passed to {@link AwaiterMulti.waitUntil} calls `waitUntil` again,
+ * that second promise will also be awaited.
+ */
+export declare class AwaiterMulti {
+    private promises;
+    private onError;
+    constructor({ onError }?: {
+        onError?: (error: unknown) => void;
+    });
+    waitUntil: (promise: Promise<unknown>) => void;
+    awaiting(): Promise<void>;
+}
+/**
+ * Like {@link AwaiterMulti}, but can only be awaited once.
+ * If {@link AwaiterOnce.waitUntil} is called after that, it will throw.
+ */
+export declare class AwaiterOnce {
+    private awaiter;
+    private done;
+    private pending;
+    constructor(options?: {
+        onError?: (error: unknown) => void;
+    });
+    waitUntil: (promise: Promise<unknown>) => void;
+    awaiting(): Promise<void>;
+}

frontend/webapp/node_modules/next/dist/server/after/awaiter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AwaiterMulti: null,
+    AwaiterOnce: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AwaiterMulti: function() {
+        return AwaiterMulti;
+    },
+    AwaiterOnce: function() {
+        return AwaiterOnce;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+class AwaiterMulti {
+    constructor({ onError } = {}){
+        this.promises = new Set();
+        this.waitUntil = (promise)=>{
+            // if a promise settles before we await it, we should drop it --
+            // storing them indefinitely could result in a memory leak.
+            const cleanup = ()=>{
+                this.promises.delete(promise);
+            };
+            promise.then(cleanup, (err)=>{
+                cleanup();
+                this.onError(err);
+            });
+            this.promises.add(promise);
+        };
+        this.onError = onError ?? console.error;
+    }
+    async awaiting() {
+        while(this.promises.size > 0){
+            const promises = Array.from(this.promises);
+            this.promises.clear();
+            await Promise.allSettled(promises);
+        }
+    }
+}
+class AwaiterOnce {
+    constructor(options = {}){
+        this.done = false;
+        this.waitUntil = (promise)=>{
+            if (this.done) {
+                throw Object.defineProperty(new _invarianterror.InvariantError('Cannot call waitUntil() on an AwaiterOnce that was already awaited'), "__NEXT_ERROR_CODE", {
+                    value: "E563",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            return this.awaiter.waitUntil(promise);
+        };
+        this.awaiter = new AwaiterMulti(options);
+    }
+    async awaiting() {
+        if (!this.pending) {
+            this.pending = this.awaiter.awaiting().finally(()=>{
+                this.done = true;
+            });
+        }
+        return this.pending;
+    }
+}
+
+//# sourceMappingURL=awaiter.js.map

frontend/webapp/node_modules/next/dist/server/after/awaiter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/after/awaiter.ts"],"sourcesContent":["import { InvariantError } from '../../shared/lib/invariant-error'\n\n/**\n * Provides a `waitUntil` implementation which gathers promises to be awaited later (via {@link AwaiterMulti.awaiting}).\n * Unlike a simple `Promise.all`, {@link AwaiterMulti} works recursively --\n * if a promise passed to {@link AwaiterMulti.waitUntil} calls `waitUntil` again,\n * that second promise will also be awaited.\n */\nexport class AwaiterMulti {\n  private promises: Set<Promise<unknown>> = new Set()\n  private onError: (error: unknown) => void\n\n  constructor({ onError }: { onError?: (error: unknown) => void } = {}) {\n    this.onError = onError ?? console.error\n  }\n\n  public waitUntil = (promise: Promise<unknown>): void => {\n    // if a promise settles before we await it, we should drop it --\n    // storing them indefinitely could result in a memory leak.\n    const cleanup = () => {\n      this.promises.delete(promise)\n    }\n\n    promise.then(cleanup, (err) => {\n      cleanup()\n      this.onError(err)\n    })\n\n    this.promises.add(promise)\n  }\n\n  public async awaiting(): Promise<void> {\n    while (this.promises.size > 0) {\n      const promises = Array.from(this.promises)\n      this.promises.clear()\n      await Promise.allSettled(promises)\n    }\n  }\n}\n\n/**\n * Like {@link AwaiterMulti}, but can only be awaited once.\n * If {@link AwaiterOnce.waitUntil} is called after that, it will throw.\n */\nexport class AwaiterOnce {\n  private awaiter: AwaiterMulti\n  private done: boolean = false\n  private pending: Promise<void> | undefined\n\n  constructor(options: { onError?: (error: unknown) => void } = {}) {\n    this.awaiter = new AwaiterMulti(options)\n  }\n\n  public waitUntil = (promise: Promise<unknown>): void => {\n    if (this.done) {\n      throw new InvariantError(\n        'Cannot call waitUntil() on an AwaiterOnce that was already awaited'\n      )\n    }\n    return this.awaiter.waitUntil(promise)\n  }\n\n  public async awaiting(): Promise<void> {\n    if (!this.pending) {\n      this.pending = this.awaiter.awaiting().finally(() => {\n        this.done = true\n      })\n    }\n    return this.pending\n  }\n}\n"],"names":["AwaiterMulti","AwaiterOnce","constructor","onError","promises","Set","waitUntil","promise","cleanup","delete","then","err","add","console","error","awaiting","size","Array","from","clear","Promise","allSettled","options","done","InvariantError","awaiter","pending","finally"],"mappings":";;;;;;;;;;;;;;;IAQaA,YAAY;eAAZA;;IAoCAC,WAAW;eAAXA;;;gCA5CkB;AAQxB,MAAMD;IAIXE,YAAY,EAAEC,OAAO,EAA0C,GAAG,CAAC,CAAC,CAAE;aAH9DC,WAAkC,IAAIC;aAOvCC,YAAY,CAACC;YAClB,gEAAgE;YAChE,2DAA2D;YAC3D,MAAMC,UAAU;gBACd,IAAI,CAACJ,QAAQ,CAACK,MAAM,CAACF;YACvB;YAEAA,QAAQG,IAAI,CAACF,SAAS,CAACG;gBACrBH;gBACA,IAAI,CAACL,OAAO,CAACQ;YACf;YAEA,IAAI,CAACP,QAAQ,CAACQ,GAAG,CAACL;QACpB;QAhBE,IAAI,CAACJ,OAAO,GAAGA,WAAWU,QAAQC,KAAK;IACzC;IAiBA,MAAaC,WAA0B;QACrC,MAAO,IAAI,CAACX,QAAQ,CAACY,IAAI,GAAG,EAAG;YAC7B,MAAMZ,WAAWa,MAAMC,IAAI,CAAC,IAAI,CAACd,QAAQ;YACzC,IAAI,CAACA,QAAQ,CAACe,KAAK;YACnB,MAAMC,QAAQC,UAAU,CAACjB;QAC3B;IACF;AACF;AAMO,MAAMH;IAKXC,YAAYoB,UAAkD,CAAC,CAAC,CAAE;aAH1DC,OAAgB;aAOjBjB,YAAY,CAACC;YAClB,IAAI,IAAI,CAACgB,IAAI,EAAE;gBACb,MAAM,qBAEL,CAFK,IAAIC,8BAAc,CACtB,uEADI,qBAAA;2BAAA;gCAAA;kCAAA;gBAEN;YACF;YACA,OAAO,IAAI,CAACC,OAAO,CAACnB,SAAS,CAACC;QAChC;QAVE,IAAI,CAACkB,OAAO,GAAG,IAAIzB,aAAasB;IAClC;IAWA,MAAaP,WAA0B;QACrC,IAAI,CAAC,IAAI,CAACW,OAAO,EAAE;YACjB,IAAI,CAACA,OAAO,GAAG,IAAI,CAACD,OAAO,CAACV,QAAQ,GAAGY,OAAO,CAAC;gBAC7C,IAAI,CAACJ,IAAI,GAAG;YACd;QACF;QACA,OAAO,IAAI,CAACG,OAAO;IACrB;AACF"}

frontend/webapp/node_modules/next/dist/server/after/builtin-request-context.d.ts

@@ -0,0 +1,17 @@
+export declare function getBuiltinRequestContext(): BuiltinRequestContextValue | undefined;
+/** A request context provided by the platform. */
+export type BuiltinRequestContext = {
+    get(): BuiltinRequestContextValue | undefined;
+};
+export type RunnableBuiltinRequestContext = BuiltinRequestContext & {
+    run<T>(value: BuiltinRequestContextValue, callback: () => T): T;
+};
+export type BuiltinRequestContextValue = {
+    waitUntil?: WaitUntil;
+};
+export type WaitUntil = (promise: Promise<any>) => void;
+/** "@next/request-context" has a different signature from AsyncLocalStorage,
+ * matching [AsyncContext.Variable](https://github.com/tc39/proposal-async-context).
+ * We don't need a full AsyncContext adapter here, just having `.get()` is enough
+ */
+export declare function createLocalRequestContext(): RunnableBuiltinRequestContext;

frontend/webapp/node_modules/next/dist/server/after/builtin-request-context.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createLocalRequestContext: null,
+    getBuiltinRequestContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLocalRequestContext: function() {
+        return createLocalRequestContext;
+    },
+    getBuiltinRequestContext: function() {
+        return getBuiltinRequestContext;
+    }
+});
+const _asynclocalstorage = require("../app-render/async-local-storage");
+function getBuiltinRequestContext() {
+    const _globalThis = globalThis;
+    const ctx = _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL];
+    return ctx == null ? void 0 : ctx.get();
+}
+const NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for('@next/request-context');
+function createLocalRequestContext() {
+    const storage = (0, _asynclocalstorage.createAsyncLocalStorage)();
+    return {
+        get: ()=>storage.getStore(),
+        run: (value, callback)=>storage.run(value, callback)
+    };
+}
+
+//# sourceMappingURL=builtin-request-context.js.map

frontend/webapp/node_modules/next/dist/server/after/builtin-request-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/after/builtin-request-context.ts"],"sourcesContent":["import { createAsyncLocalStorage } from '../app-render/async-local-storage'\n\nexport function getBuiltinRequestContext():\n  | BuiltinRequestContextValue\n  | undefined {\n  const _globalThis = globalThis as GlobalThisWithRequestContext\n  const ctx = _globalThis[NEXT_REQUEST_CONTEXT_SYMBOL]\n  return ctx?.get()\n}\n\nconst NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for('@next/request-context')\n\ntype GlobalThisWithRequestContext = typeof globalThis & {\n  [NEXT_REQUEST_CONTEXT_SYMBOL]?: BuiltinRequestContext\n}\n\n/** A request context provided by the platform. */\nexport type BuiltinRequestContext = {\n  get(): BuiltinRequestContextValue | undefined\n}\n\nexport type RunnableBuiltinRequestContext = BuiltinRequestContext & {\n  run<T>(value: BuiltinRequestContextValue, callback: () => T): T\n}\n\nexport type BuiltinRequestContextValue = {\n  waitUntil?: WaitUntil\n}\nexport type WaitUntil = (promise: Promise<any>) => void\n\n/** \"@next/request-context\" has a different signature from AsyncLocalStorage,\n * matching [AsyncContext.Variable](https://github.com/tc39/proposal-async-context).\n * We don't need a full AsyncContext adapter here, just having `.get()` is enough\n */\nexport function createLocalRequestContext(): RunnableBuiltinRequestContext {\n  const storage = createAsyncLocalStorage<BuiltinRequestContextValue>()\n  return {\n    get: () => storage.getStore(),\n    run: (value, callback) => storage.run(value, callback),\n  }\n}\n"],"names":["createLocalRequestContext","getBuiltinRequestContext","_globalThis","globalThis","ctx","NEXT_REQUEST_CONTEXT_SYMBOL","get","Symbol","for","storage","createAsyncLocalStorage","getStore","run","value","callback"],"mappings":";;;;;;;;;;;;;;;IAkCgBA,yBAAyB;eAAzBA;;IAhCAC,wBAAwB;eAAxBA;;;mCAFwB;AAEjC,SAASA;IAGd,MAAMC,cAAcC;IACpB,MAAMC,MAAMF,WAAW,CAACG,4BAA4B;IACpD,OAAOD,uBAAAA,IAAKE,GAAG;AACjB;AAEA,MAAMD,8BAA8BE,OAAOC,GAAG,CAAC;AAwBxC,SAASR;IACd,MAAMS,UAAUC,IAAAA,0CAAuB;IACvC,OAAO;QACLJ,KAAK,IAAMG,QAAQE,QAAQ;QAC3BC,KAAK,CAACC,OAAOC,WAAaL,QAAQG,GAAG,CAACC,OAAOC;IAC/C;AACF"}

frontend/webapp/node_modules/next/dist/server/after/index.d.ts

@@ -0,0 +1 @@
+export * from './after';

frontend/webapp/node_modules/next/dist/server/after/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && __export(require("./after"));
+_export_star(require("./after"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

frontend/webapp/node_modules/next/dist/server/after/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/after/index.ts"],"sourcesContent":["export * from './after'\n"],"names":[],"mappings":";;;;;qBAAc"}

frontend/webapp/node_modules/next/dist/server/after/run-with-after.d.ts

@@ -0,0 +1,14 @@
+import type { AfterContextOpts } from './after-context';
+type Ctx = {
+    waitUntil: NonNullable<AfterContextOpts['waitUntil']>;
+    onClose: NonNullable<AfterContextOpts['onClose']>;
+    onTaskError: NonNullable<AfterContextOpts['onTaskError']>;
+};
+export declare class AfterRunner {
+    private awaiter;
+    private closeController;
+    private finishedWithoutErrors;
+    readonly context: Ctx;
+    executeAfter(): Promise<void>;
+}
+export {};

frontend/webapp/node_modules/next/dist/server/after/run-with-after.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AfterRunner", {
+    enumerable: true,
+    get: function() {
+        return AfterRunner;
+    }
+});
+const _detachedpromise = require("../../lib/detached-promise");
+const _webonclose = require("../web/web-on-close");
+const _awaiter = require("./awaiter");
+class AfterRunner {
+    async executeAfter() {
+        this.closeController.dispatchClose();
+        await this.awaiter.awaiting();
+        // if we got an error while running the callbacks,
+        // thenthis is a noop, because the promise is already rejected
+        this.finishedWithoutErrors.resolve();
+        return this.finishedWithoutErrors.promise;
+    }
+    constructor(){
+        this.awaiter = new _awaiter.AwaiterOnce();
+        this.closeController = new _webonclose.CloseController();
+        this.finishedWithoutErrors = new _detachedpromise.DetachedPromise();
+        this.context = {
+            waitUntil: this.awaiter.waitUntil.bind(this.awaiter),
+            onClose: this.closeController.onClose.bind(this.closeController),
+            onTaskError: (error)=>this.finishedWithoutErrors.reject(error)
+        };
+    }
+}
+
+//# sourceMappingURL=run-with-after.js.map

frontend/webapp/node_modules/next/dist/server/after/run-with-after.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/after/run-with-after.ts"],"sourcesContent":["import { DetachedPromise } from '../../lib/detached-promise'\nimport { CloseController } from '../web/web-on-close'\nimport type { AfterContextOpts } from './after-context'\nimport { AwaiterOnce } from './awaiter'\n\ntype Ctx = {\n  waitUntil: NonNullable<AfterContextOpts['waitUntil']>\n  onClose: NonNullable<AfterContextOpts['onClose']>\n  onTaskError: NonNullable<AfterContextOpts['onTaskError']>\n}\n\nexport class AfterRunner {\n  private awaiter = new AwaiterOnce()\n  private closeController = new CloseController()\n  private finishedWithoutErrors = new DetachedPromise<void>()\n\n  readonly context: Ctx = {\n    waitUntil: this.awaiter.waitUntil.bind(this.awaiter),\n    onClose: this.closeController.onClose.bind(this.closeController),\n    onTaskError: (error) => this.finishedWithoutErrors.reject(error),\n  }\n\n  public async executeAfter() {\n    this.closeController.dispatchClose()\n    await this.awaiter.awaiting()\n\n    // if we got an error while running the callbacks,\n    // thenthis is a noop, because the promise is already rejected\n    this.finishedWithoutErrors.resolve()\n\n    return this.finishedWithoutErrors.promise\n  }\n}\n"],"names":["AfterRunner","executeAfter","closeController","dispatchClose","awaiter","awaiting","finishedWithoutErrors","resolve","promise","AwaiterOnce","CloseController","DetachedPromise","context","waitUntil","bind","onClose","onTaskError","error","reject"],"mappings":";;;;+BAWaA;;;eAAAA;;;iCAXmB;4BACA;yBAEJ;AAQrB,MAAMA;IAWX,MAAaC,eAAe;QAC1B,IAAI,CAACC,eAAe,CAACC,aAAa;QAClC,MAAM,IAAI,CAACC,OAAO,CAACC,QAAQ;QAE3B,kDAAkD;QAClD,8DAA8D;QAC9D,IAAI,CAACC,qBAAqB,CAACC,OAAO;QAElC,OAAO,IAAI,CAACD,qBAAqB,CAACE,OAAO;IAC3C;;aAnBQJ,UAAU,IAAIK,oBAAW;aACzBP,kBAAkB,IAAIQ,2BAAe;aACrCJ,wBAAwB,IAAIK,gCAAe;aAE1CC,UAAe;YACtBC,WAAW,IAAI,CAACT,OAAO,CAACS,SAAS,CAACC,IAAI,CAAC,IAAI,CAACV,OAAO;YACnDW,SAAS,IAAI,CAACb,eAAe,CAACa,OAAO,CAACD,IAAI,CAAC,IAAI,CAACZ,eAAe;YAC/Dc,aAAa,CAACC,QAAU,IAAI,CAACX,qBAAqB,CAACY,MAAM,CAACD;QAC5D;;AAYF"}

frontend/webapp/node_modules/next/dist/server/api-utils/get-cookie-parser.d.ts

@@ -0,0 +1,8 @@
+import type { NextApiRequestCookies } from '.';
+/**
+ * Parse cookies from the `headers` of request
+ * @param req request object
+ */
+export declare function getCookieParser(headers: {
+    [key: string]: string | string[] | null | undefined;
+}): () => NextApiRequestCookies;

frontend/webapp/node_modules/next/dist/server/api-utils/get-cookie-parser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCookieParser", {
+    enumerable: true,
+    get: function() {
+        return getCookieParser;
+    }
+});
+function getCookieParser(headers) {
+    return function parseCookie() {
+        const { cookie } = headers;
+        if (!cookie) {
+            return {};
+        }
+        const { parse: parseCookieFn } = require('next/dist/compiled/cookie');
+        return parseCookieFn(Array.isArray(cookie) ? cookie.join('; ') : cookie);
+    };
+}
+
+//# sourceMappingURL=get-cookie-parser.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/get-cookie-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/api-utils/get-cookie-parser.ts"],"sourcesContent":["import type { NextApiRequestCookies } from '.'\n\n/**\n * Parse cookies from the `headers` of request\n * @param req request object\n */\n\nexport function getCookieParser(headers: {\n  [key: string]: string | string[] | null | undefined\n}): () => NextApiRequestCookies {\n  return function parseCookie(): NextApiRequestCookies {\n    const { cookie } = headers\n\n    if (!cookie) {\n      return {}\n    }\n\n    const { parse: parseCookieFn } = require('next/dist/compiled/cookie')\n    return parseCookieFn(Array.isArray(cookie) ? cookie.join('; ') : cookie)\n  }\n}\n"],"names":["getCookieParser","headers","parseCookie","cookie","parse","parseCookieFn","require","Array","isArray","join"],"mappings":";;;;+BAOgBA;;;eAAAA;;;AAAT,SAASA,gBAAgBC,OAE/B;IACC,OAAO,SAASC;QACd,MAAM,EAAEC,MAAM,EAAE,GAAGF;QAEnB,IAAI,CAACE,QAAQ;YACX,OAAO,CAAC;QACV;QAEA,MAAM,EAAEC,OAAOC,aAAa,EAAE,GAAGC,QAAQ;QACzC,OAAOD,cAAcE,MAAMC,OAAO,CAACL,UAAUA,OAAOM,IAAI,CAAC,QAAQN;IACnE;AACF"}

frontend/webapp/node_modules/next/dist/server/api-utils/index.d.ts

@@ -0,0 +1,65 @@
+import type { IncomingMessage } from 'http';
+import type { BaseNextRequest } from '../base-http';
+import type { NextApiResponse } from '../../shared/lib/utils';
+export type NextApiRequestCookies = Partial<{
+    [key: string]: string;
+}>;
+export type NextApiRequestQuery = Partial<{
+    [key: string]: string | string[];
+}>;
+export type __ApiPreviewProps = {
+    previewModeId: string;
+    previewModeEncryptionKey: string;
+    previewModeSigningKey: string;
+};
+export declare function wrapApiHandler<T extends (...args: any[]) => any>(page: string, handler: T): T;
+/**
+ *
+ * @param res response object
+ * @param statusCode `HTTP` status code of response
+ */
+export declare function sendStatusCode(res: NextApiResponse, statusCode: number): NextApiResponse<any>;
+/**
+ *
+ * @param res response object
+ * @param [statusOrUrl] `HTTP` status code of redirect
+ * @param url URL of redirect
+ */
+export declare function redirect(res: NextApiResponse, statusOrUrl: string | number, url?: string): NextApiResponse<any>;
+export declare function checkIsOnDemandRevalidate(req: Request | IncomingMessage | BaseNextRequest, previewProps: __ApiPreviewProps): {
+    isOnDemandRevalidate: boolean;
+    revalidateOnlyGenerated: boolean;
+};
+export declare const COOKIE_NAME_PRERENDER_BYPASS = "__prerender_bypass";
+export declare const COOKIE_NAME_PRERENDER_DATA = "__next_preview_data";
+export declare const RESPONSE_LIMIT_DEFAULT: number;
+export declare const SYMBOL_PREVIEW_DATA: unique symbol;
+export declare const SYMBOL_CLEARED_COOKIES: unique symbol;
+export declare function clearPreviewData<T>(res: NextApiResponse<T>, options?: {
+    path?: string;
+}): NextApiResponse<T>;
+/**
+ * Custom error class
+ */
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+/**
+ * Sends error in `response`
+ * @param res response object
+ * @param statusCode of response
+ * @param message of response
+ */
+export declare function sendError(res: NextApiResponse, statusCode: number, message: string): void;
+interface LazyProps {
+    req: IncomingMessage;
+}
+/**
+ * Execute getter function only if its needed
+ * @param LazyProps `req` and `params` for lazyProp
+ * @param prop name of property
+ * @param getter function to get data
+ */
+export declare function setLazyProp<T>({ req }: LazyProps, prop: string, getter: () => T): void;
+export {};

frontend/webapp/node_modules/next/dist/server/api-utils/index.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ApiError: null,
+    COOKIE_NAME_PRERENDER_BYPASS: null,
+    COOKIE_NAME_PRERENDER_DATA: null,
+    RESPONSE_LIMIT_DEFAULT: null,
+    SYMBOL_CLEARED_COOKIES: null,
+    SYMBOL_PREVIEW_DATA: null,
+    checkIsOnDemandRevalidate: null,
+    clearPreviewData: null,
+    redirect: null,
+    sendError: null,
+    sendStatusCode: null,
+    setLazyProp: null,
+    wrapApiHandler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ApiError: function() {
+        return ApiError;
+    },
+    COOKIE_NAME_PRERENDER_BYPASS: function() {
+        return COOKIE_NAME_PRERENDER_BYPASS;
+    },
+    COOKIE_NAME_PRERENDER_DATA: function() {
+        return COOKIE_NAME_PRERENDER_DATA;
+    },
+    RESPONSE_LIMIT_DEFAULT: function() {
+        return RESPONSE_LIMIT_DEFAULT;
+    },
+    SYMBOL_CLEARED_COOKIES: function() {
+        return SYMBOL_CLEARED_COOKIES;
+    },
+    SYMBOL_PREVIEW_DATA: function() {
+        return SYMBOL_PREVIEW_DATA;
+    },
+    checkIsOnDemandRevalidate: function() {
+        return checkIsOnDemandRevalidate;
+    },
+    clearPreviewData: function() {
+        return clearPreviewData;
+    },
+    redirect: function() {
+        return redirect;
+    },
+    sendError: function() {
+        return sendError;
+    },
+    sendStatusCode: function() {
+        return sendStatusCode;
+    },
+    setLazyProp: function() {
+        return setLazyProp;
+    },
+    wrapApiHandler: function() {
+        return wrapApiHandler;
+    }
+});
+const _headers = require("../web/spec-extension/adapters/headers");
+const _constants = require("../../lib/constants");
+const _tracer = require("../lib/trace/tracer");
+const _constants1 = require("../lib/trace/constants");
+function wrapApiHandler(page, handler) {
+    return (...args)=>{
+        (0, _tracer.getTracer)().setRootSpanAttribute('next.route', page);
+        // Call API route method
+        return (0, _tracer.getTracer)().trace(_constants1.NodeSpan.runHandler, {
+            spanName: `executing api route (pages) ${page}`
+        }, ()=>handler(...args));
+    };
+}
+function sendStatusCode(res, statusCode) {
+    res.statusCode = statusCode;
+    return res;
+}
+function redirect(res, statusOrUrl, url) {
+    if (typeof statusOrUrl === 'string') {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+    }
+    if (typeof statusOrUrl !== 'number' || typeof url !== 'string') {
+        throw Object.defineProperty(new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`), "__NEXT_ERROR_CODE", {
+            value: "E389",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    res.writeHead(statusOrUrl, {
+        Location: url
+    });
+    res.write(url);
+    res.end();
+    return res;
+}
+function checkIsOnDemandRevalidate(req, previewProps) {
+    const headers = _headers.HeadersAdapter.from(req.headers);
+    const previewModeId = headers.get(_constants.PRERENDER_REVALIDATE_HEADER);
+    const isOnDemandRevalidate = previewModeId === previewProps.previewModeId;
+    const revalidateOnlyGenerated = headers.has(_constants.PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER);
+    return {
+        isOnDemandRevalidate,
+        revalidateOnlyGenerated
+    };
+}
+const COOKIE_NAME_PRERENDER_BYPASS = `__prerender_bypass`;
+const COOKIE_NAME_PRERENDER_DATA = `__next_preview_data`;
+const RESPONSE_LIMIT_DEFAULT = 4 * 1024 * 1024;
+const SYMBOL_PREVIEW_DATA = Symbol(COOKIE_NAME_PRERENDER_DATA);
+const SYMBOL_CLEARED_COOKIES = Symbol(COOKIE_NAME_PRERENDER_BYPASS);
+function clearPreviewData(res, options = {}) {
+    if (SYMBOL_CLEARED_COOKIES in res) {
+        return res;
+    }
+    const { serialize } = require('next/dist/compiled/cookie');
+    const previous = res.getHeader('Set-Cookie');
+    res.setHeader(`Set-Cookie`, [
+        ...typeof previous === 'string' ? [
+            previous
+        ] : Array.isArray(previous) ? previous : [],
+        serialize(COOKIE_NAME_PRERENDER_BYPASS, '', {
+            // To delete a cookie, set `expires` to a date in the past:
+            // https://tools.ietf.org/html/rfc6265#section-4.1.1
+            // `Max-Age: 0` is not valid, thus ignored, and the cookie is persisted.
+            expires: new Date(0),
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            ...options.path !== undefined ? {
+                path: options.path
+            } : undefined
+        }),
+        serialize(COOKIE_NAME_PRERENDER_DATA, '', {
+            // To delete a cookie, set `expires` to a date in the past:
+            // https://tools.ietf.org/html/rfc6265#section-4.1.1
+            // `Max-Age: 0` is not valid, thus ignored, and the cookie is persisted.
+            expires: new Date(0),
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            ...options.path !== undefined ? {
+                path: options.path
+            } : undefined
+        })
+    ]);
+    Object.defineProperty(res, SYMBOL_CLEARED_COOKIES, {
+        value: true,
+        enumerable: false
+    });
+    return res;
+}
+class ApiError extends Error {
+    constructor(statusCode, message){
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function sendError(res, statusCode, message) {
+    res.statusCode = statusCode;
+    res.statusMessage = message;
+    res.end(message);
+}
+function setLazyProp({ req }, prop, getter) {
+    const opts = {
+        configurable: true,
+        enumerable: true
+    };
+    const optsReset = {
+        ...opts,
+        writable: true
+    };
+    Object.defineProperty(req, prop, {
+        ...opts,
+        get: ()=>{
+            const value = getter();
+            // we set the property on the object to avoid recalculating it
+            Object.defineProperty(req, prop, {
+                ...optsReset,
+                value
+            });
+            return value;
+        },
+        set: (value)=>{
+            Object.defineProperty(req, prop, {
+                ...optsReset,
+                value
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=index.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/node/api-resolver.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { __ApiPreviewProps } from '../.';
+import type { ServerOnInstrumentationRequestError } from '../../app-render/types';
+type RevalidateFn = (config: {
+    urlPath: string;
+    revalidateHeaders: {
+        [key: string]: string | string[];
+    };
+    opts: {
+        unstable_onlyGenerated?: boolean;
+    };
+}) => Promise<void>;
+type ApiContext = __ApiPreviewProps & {
+    trustHostHeader?: boolean;
+    allowedRevalidateHeaderKeys?: string[];
+    hostname?: string;
+    revalidate?: RevalidateFn;
+    multiZoneDraftMode?: boolean;
+    dev: boolean;
+};
+export declare function apiResolver(req: IncomingMessage, res: ServerResponse, query: any, resolverModule: any, apiContext: ApiContext, propagateError: boolean, dev?: boolean, page?: string, onError?: ServerOnInstrumentationRequestError): Promise<void>;
+export {};

frontend/webapp/node_modules/next/dist/server/api-utils/node/api-resolver.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "apiResolver", {
+    enumerable: true,
+    get: function() {
+        return apiResolver;
+    }
+});
+const _bytes = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/bytes"));
+const _etag = require("../../lib/etag");
+const _sendpayload = require("../../send-payload");
+const _stream = require("stream");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is-error"));
+const _utils = require("../../../shared/lib/utils");
+const _interopdefault = require("../../../lib/interop-default");
+const _index = require("./../index");
+const _getcookieparser = require("./../get-cookie-parser");
+const _constants = require("../../../lib/constants");
+const _trygetpreviewdata = require("./try-get-preview-data");
+const _parsebody = require("./parse-body");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getMaxContentLength(responseLimit) {
+    if (responseLimit && typeof responseLimit !== 'boolean') {
+        return _bytes.default.parse(responseLimit);
+    }
+    return _index.RESPONSE_LIMIT_DEFAULT;
+}
+/**
+ * Send `any` body to response
+ * @param req request object
+ * @param res response object
+ * @param body of response
+ */ function sendData(req, res, body) {
+    if (body === null || body === undefined) {
+        res.end();
+        return;
+    }
+    // strip irrelevant headers/body
+    if (res.statusCode === 204 || res.statusCode === 304) {
+        res.removeHeader('Content-Type');
+        res.removeHeader('Content-Length');
+        res.removeHeader('Transfer-Encoding');
+        if (process.env.NODE_ENV === 'development' && body) {
+            console.warn(`A body was attempted to be set with a 204 statusCode for ${req.url}, this is invalid and the body was ignored.\n` + `See more info here https://nextjs.org/docs/messages/invalid-api-status-body`);
+        }
+        res.end();
+        return;
+    }
+    const contentType = res.getHeader('Content-Type');
+    if (body instanceof _stream.Stream) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        body.pipe(res);
+        return;
+    }
+    const isJSONLike = [
+        'object',
+        'number',
+        'boolean'
+    ].includes(typeof body);
+    const stringifiedBody = isJSONLike ? JSON.stringify(body) : body;
+    const etag = (0, _etag.generateETag)(stringifiedBody);
+    if ((0, _sendpayload.sendEtagResponse)(req, res, etag)) {
+        return;
+    }
+    if (Buffer.isBuffer(body)) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        res.setHeader('Content-Length', body.length);
+        res.end(body);
+        return;
+    }
+    if (isJSONLike) {
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    res.setHeader('Content-Length', Buffer.byteLength(stringifiedBody));
+    res.end(stringifiedBody);
+}
+/**
+ * Send `JSON` object
+ * @param res response object
+ * @param jsonBody of data
+ */ function sendJson(res, jsonBody) {
+    // Set header to application/json
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    // Use send to handle request
+    res.send(JSON.stringify(jsonBody));
+}
+function isValidData(str) {
+    return typeof str === 'string' && str.length >= 16;
+}
+function setDraftMode(res, options) {
+    if (!isValidData(options.previewModeId)) {
+        throw Object.defineProperty(new Error('invariant: invalid previewModeId'), "__NEXT_ERROR_CODE", {
+            value: "E169",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const expires = options.enable ? undefined : new Date(0);
+    // To delete a cookie, set `expires` to a date in the past:
+    // https://tools.ietf.org/html/rfc6265#section-4.1.1
+    // `Max-Age: 0` is not valid, thus ignored, and the cookie is persisted.
+    const { serialize } = require('next/dist/compiled/cookie');
+    const previous = res.getHeader('Set-Cookie');
+    res.setHeader(`Set-Cookie`, [
+        ...typeof previous === 'string' ? [
+            previous
+        ] : Array.isArray(previous) ? previous : [],
+        serialize(_index.COOKIE_NAME_PRERENDER_BYPASS, options.previewModeId, {
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            expires
+        })
+    ]);
+    return res;
+}
+function setPreviewData(res, data, options) {
+    if (!isValidData(options.previewModeId)) {
+        throw Object.defineProperty(new Error('invariant: invalid previewModeId'), "__NEXT_ERROR_CODE", {
+            value: "E169",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (!isValidData(options.previewModeEncryptionKey)) {
+        throw Object.defineProperty(new Error('invariant: invalid previewModeEncryptionKey'), "__NEXT_ERROR_CODE", {
+            value: "E334",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (!isValidData(options.previewModeSigningKey)) {
+        throw Object.defineProperty(new Error('invariant: invalid previewModeSigningKey'), "__NEXT_ERROR_CODE", {
+            value: "E436",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const jsonwebtoken = require('next/dist/compiled/jsonwebtoken');
+    const { encryptWithSecret } = require('../../crypto-utils');
+    const payload = jsonwebtoken.sign({
+        data: encryptWithSecret(Buffer.from(options.previewModeEncryptionKey), JSON.stringify(data))
+    }, options.previewModeSigningKey, {
+        algorithm: 'HS256',
+        ...options.maxAge !== undefined ? {
+            expiresIn: options.maxAge
+        } : undefined
+    });
+    // limit preview mode cookie to 2KB since we shouldn't store too much
+    // data here and browsers drop cookies over 4KB
+    if (payload.length > 2048) {
+        throw Object.defineProperty(new Error(`Preview data is limited to 2KB currently, reduce how much data you are storing as preview data to continue`), "__NEXT_ERROR_CODE", {
+            value: "E465",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const { serialize } = require('next/dist/compiled/cookie');
+    const previous = res.getHeader('Set-Cookie');
+    res.setHeader(`Set-Cookie`, [
+        ...typeof previous === 'string' ? [
+            previous
+        ] : Array.isArray(previous) ? previous : [],
+        serialize(_index.COOKIE_NAME_PRERENDER_BYPASS, options.previewModeId, {
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            ...options.maxAge !== undefined ? {
+                maxAge: options.maxAge
+            } : undefined,
+            ...options.path !== undefined ? {
+                path: options.path
+            } : undefined
+        }),
+        serialize(_index.COOKIE_NAME_PRERENDER_DATA, payload, {
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            ...options.maxAge !== undefined ? {
+                maxAge: options.maxAge
+            } : undefined,
+            ...options.path !== undefined ? {
+                path: options.path
+            } : undefined
+        })
+    ]);
+    return res;
+}
+async function revalidate(urlPath, opts, req, context) {
+    if (typeof urlPath !== 'string' || !urlPath.startsWith('/')) {
+        throw Object.defineProperty(new Error(`Invalid urlPath provided to revalidate(), must be a path e.g. /blog/post-1, received ${urlPath}`), "__NEXT_ERROR_CODE", {
+            value: "E153",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const revalidateHeaders = {
+        [_constants.PRERENDER_REVALIDATE_HEADER]: context.previewModeId,
+        ...opts.unstable_onlyGenerated ? {
+            [_constants.PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER]: '1'
+        } : {}
+    };
+    const allowedRevalidateHeaderKeys = [
+        ...context.allowedRevalidateHeaderKeys || []
+    ];
+    if (context.trustHostHeader || context.dev) {
+        allowedRevalidateHeaderKeys.push('cookie');
+    }
+    if (context.trustHostHeader) {
+        allowedRevalidateHeaderKeys.push('x-vercel-protection-bypass');
+    }
+    for (const key of Object.keys(req.headers)){
+        if (allowedRevalidateHeaderKeys.includes(key)) {
+            revalidateHeaders[key] = req.headers[key];
+        }
+    }
+    try {
+        if (context.trustHostHeader) {
+            const res = await fetch(`https://${req.headers.host}${urlPath}`, {
+                method: 'HEAD',
+                headers: revalidateHeaders
+            });
+            // we use the cache header to determine successful revalidate as
+            // a non-200 status code can be returned from a successful revalidate
+            // e.g. notFound: true returns 404 status code but is successful
+            const cacheHeader = res.headers.get('x-vercel-cache') || res.headers.get('x-nextjs-cache');
+            if ((cacheHeader == null ? void 0 : cacheHeader.toUpperCase()) !== 'REVALIDATED' && res.status !== 200 && !(res.status === 404 && opts.unstable_onlyGenerated)) {
+                throw Object.defineProperty(new Error(`Invalid response ${res.status}`), "__NEXT_ERROR_CODE", {
+                    value: "E175",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else if (context.revalidate) {
+            await context.revalidate({
+                urlPath,
+                revalidateHeaders,
+                opts
+            });
+        } else {
+            throw Object.defineProperty(new Error(`Invariant: required internal revalidate method not passed to api-utils`), "__NEXT_ERROR_CODE", {
+                value: "E174",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    } catch (err) {
+        throw Object.defineProperty(new Error(`Failed to revalidate ${urlPath}: ${(0, _iserror.default)(err) ? err.message : err}`), "__NEXT_ERROR_CODE", {
+            value: "E240",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function apiResolver(req, res, query, resolverModule, apiContext, propagateError, dev, page, onError) {
+    const apiReq = req;
+    const apiRes = res;
+    try {
+        var _config_api, _config_api1, _config_api2;
+        if (!resolverModule) {
+            res.statusCode = 404;
+            res.end('Not Found');
+            return;
+        }
+        const config = resolverModule.config || {};
+        const bodyParser = ((_config_api = config.api) == null ? void 0 : _config_api.bodyParser) !== false;
+        const responseLimit = ((_config_api1 = config.api) == null ? void 0 : _config_api1.responseLimit) ?? true;
+        const externalResolver = ((_config_api2 = config.api) == null ? void 0 : _config_api2.externalResolver) || false;
+        // Parsing of cookies
+        (0, _index.setLazyProp)({
+            req: apiReq
+        }, 'cookies', (0, _getcookieparser.getCookieParser)(req.headers));
+        // Parsing query string
+        apiReq.query = query;
+        // Parsing preview data
+        (0, _index.setLazyProp)({
+            req: apiReq
+        }, 'previewData', ()=>(0, _trygetpreviewdata.tryGetPreviewData)(req, res, apiContext, !!apiContext.multiZoneDraftMode));
+        // Checking if preview mode is enabled
+        (0, _index.setLazyProp)({
+            req: apiReq
+        }, 'preview', ()=>apiReq.previewData !== false ? true : undefined);
+        // Set draftMode to the same value as preview
+        (0, _index.setLazyProp)({
+            req: apiReq
+        }, 'draftMode', ()=>apiReq.preview);
+        // Parsing of body
+        if (bodyParser && !apiReq.body) {
+            apiReq.body = await (0, _parsebody.parseBody)(apiReq, config.api && config.api.bodyParser && config.api.bodyParser.sizeLimit ? config.api.bodyParser.sizeLimit : '1mb');
+        }
+        let contentLength = 0;
+        const maxContentLength = getMaxContentLength(responseLimit);
+        const writeData = apiRes.write;
+        const endResponse = apiRes.end;
+        apiRes.write = (...args)=>{
+            contentLength += Buffer.byteLength(args[0] || '');
+            return writeData.apply(apiRes, args);
+        };
+        apiRes.end = (...args)=>{
+            if (args.length && typeof args[0] !== 'function') {
+                contentLength += Buffer.byteLength(args[0] || '');
+            }
+            if (responseLimit && contentLength >= maxContentLength) {
+                console.warn(`API response for ${req.url} exceeds ${_bytes.default.format(maxContentLength)}. API Routes are meant to respond quickly. https://nextjs.org/docs/messages/api-routes-response-size-limit`);
+            }
+            return endResponse.apply(apiRes, args);
+        };
+        apiRes.status = (statusCode)=>(0, _index.sendStatusCode)(apiRes, statusCode);
+        apiRes.send = (data)=>sendData(apiReq, apiRes, data);
+        apiRes.json = (data)=>sendJson(apiRes, data);
+        apiRes.redirect = (statusOrUrl, url)=>(0, _index.redirect)(apiRes, statusOrUrl, url);
+        apiRes.setDraftMode = (options = {
+            enable: true
+        })=>setDraftMode(apiRes, Object.assign({}, apiContext, options));
+        apiRes.setPreviewData = (data, options = {})=>setPreviewData(apiRes, data, Object.assign({}, apiContext, options));
+        apiRes.clearPreviewData = (options = {})=>(0, _index.clearPreviewData)(apiRes, options);
+        apiRes.revalidate = (urlPath, opts)=>revalidate(urlPath, opts || {}, req, apiContext);
+        const resolver = (0, _interopdefault.interopDefault)(resolverModule);
+        let wasPiped = false;
+        if (process.env.NODE_ENV !== 'production') {
+            // listen for pipe event and don't show resolve warning
+            res.once('pipe', ()=>wasPiped = true);
+        }
+        const apiRouteResult = await resolver(req, res);
+        if (process.env.NODE_ENV !== 'production') {
+            if (typeof apiRouteResult !== 'undefined') {
+                if (apiRouteResult instanceof Response) {
+                    throw Object.defineProperty(new Error('API route returned a Response object in the Node.js runtime, this is not supported. Please use `runtime: "edge"` instead: https://nextjs.org/docs/api-routes/edge-api-routes'), "__NEXT_ERROR_CODE", {
+                        value: "E36",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                console.warn(`API handler should not return a value, received ${typeof apiRouteResult}.`);
+            }
+            if (!externalResolver && !(0, _utils.isResSent)(res) && !wasPiped) {
+                console.warn(`API resolved without sending a response for ${req.url}, this may result in stalled requests.`);
+            }
+        }
+    } catch (err) {
+        onError == null ? void 0 : onError(err, req, {
+            routerKind: 'Pages Router',
+            routePath: page || '',
+            routeType: 'route',
+            revalidateReason: undefined
+        });
+        if (err instanceof _index.ApiError) {
+            (0, _index.sendError)(apiRes, err.statusCode, err.message);
+        } else {
+            if (dev) {
+                if ((0, _iserror.default)(err)) {
+                    err.page = page;
+                }
+                throw err;
+            }
+            console.error(err);
+            if (propagateError) {
+                throw err;
+            }
+            (0, _index.sendError)(apiRes, 500, 'Internal Server Error');
+        }
+    }
+}
+
+//# sourceMappingURL=api-resolver.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/node/parse-body.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage } from 'http';
+import type { SizeLimit } from '../../../types';
+/**
+ * Parse incoming message like `json` or `urlencoded`
+ * @param req request object
+ */
+export declare function parseBody(req: IncomingMessage, limit: SizeLimit): Promise<any>;

frontend/webapp/node_modules/next/dist/server/api-utils/node/parse-body.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseBody", {
+    enumerable: true,
+    get: function() {
+        return parseBody;
+    }
+});
+const _contenttype = require("next/dist/compiled/content-type");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is-error"));
+const _index = require("../index");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * Parse `JSON` and handles invalid `JSON` strings
+ * @param str `JSON` string
+ */ function parseJson(str) {
+    if (str.length === 0) {
+        // special-case empty json body, as it's a common client-side mistake
+        return {};
+    }
+    try {
+        return JSON.parse(str);
+    } catch (e) {
+        throw Object.defineProperty(new _index.ApiError(400, 'Invalid JSON'), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function parseBody(req, limit) {
+    let contentType;
+    try {
+        contentType = (0, _contenttype.parse)(req.headers['content-type'] || 'text/plain');
+    } catch  {
+        contentType = (0, _contenttype.parse)('text/plain');
+    }
+    const { type, parameters } = contentType;
+    const encoding = parameters.charset || 'utf-8';
+    let buffer;
+    try {
+        const getRawBody = require('next/dist/compiled/raw-body');
+        buffer = await getRawBody(req, {
+            encoding,
+            limit
+        });
+    } catch (e) {
+        if ((0, _iserror.default)(e) && e.type === 'entity.too.large') {
+            throw Object.defineProperty(new _index.ApiError(413, `Body exceeded ${limit} limit`), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        } else {
+            throw Object.defineProperty(new _index.ApiError(400, 'Invalid body'), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    const body = buffer.toString();
+    if (type === 'application/json' || type === 'application/ld+json') {
+        return parseJson(body);
+    } else if (type === 'application/x-www-form-urlencoded') {
+        const qs = require('querystring');
+        return qs.decode(body);
+    } else {
+        return body;
+    }
+}
+
+//# sourceMappingURL=parse-body.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/node/parse-body.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/api-utils/node/parse-body.ts"],"sourcesContent":["import type { IncomingMessage } from 'http'\n\nimport { parse } from 'next/dist/compiled/content-type'\nimport isError from '../../../lib/is-error'\nimport type { SizeLimit } from '../../../types'\nimport { ApiError } from '../index'\n\n/**\n * Parse `JSON` and handles invalid `JSON` strings\n * @param str `JSON` string\n */\nfunction parseJson(str: string): object {\n  if (str.length === 0) {\n    // special-case empty json body, as it's a common client-side mistake\n    return {}\n  }\n\n  try {\n    return JSON.parse(str)\n  } catch (e) {\n    throw new ApiError(400, 'Invalid JSON')\n  }\n}\n\n/**\n * Parse incoming message like `json` or `urlencoded`\n * @param req request object\n */\nexport async function parseBody(\n  req: IncomingMessage,\n  limit: SizeLimit\n): Promise<any> {\n  let contentType\n  try {\n    contentType = parse(req.headers['content-type'] || 'text/plain')\n  } catch {\n    contentType = parse('text/plain')\n  }\n  const { type, parameters } = contentType\n  const encoding = parameters.charset || 'utf-8'\n\n  let buffer\n\n  try {\n    const getRawBody =\n      require('next/dist/compiled/raw-body') as typeof import('next/dist/compiled/raw-body')\n    buffer = await getRawBody(req, { encoding, limit })\n  } catch (e) {\n    if (isError(e) && e.type === 'entity.too.large') {\n      throw new ApiError(413, `Body exceeded ${limit} limit`)\n    } else {\n      throw new ApiError(400, 'Invalid body')\n    }\n  }\n\n  const body = buffer.toString()\n\n  if (type === 'application/json' || type === 'application/ld+json') {\n    return parseJson(body)\n  } else if (type === 'application/x-www-form-urlencoded') {\n    const qs = require('querystring')\n    return qs.decode(body)\n  } else {\n    return body\n  }\n}\n"],"names":["parseBody","parseJson","str","length","JSON","parse","e","ApiError","req","limit","contentType","headers","type","parameters","encoding","charset","buffer","getRawBody","require","isError","body","toString","qs","decode"],"mappings":";;;;+BA4BsBA;;;eAAAA;;;6BA1BA;gEACF;uBAEK;;;;;;AAEzB;;;CAGC,GACD,SAASC,UAAUC,GAAW;IAC5B,IAAIA,IAAIC,MAAM,KAAK,GAAG;QACpB,qEAAqE;QACrE,OAAO,CAAC;IACV;IAEA,IAAI;QACF,OAAOC,KAAKC,KAAK,CAACH;IACpB,EAAE,OAAOI,GAAG;QACV,MAAM,qBAAiC,CAAjC,IAAIC,eAAQ,CAAC,KAAK,iBAAlB,qBAAA;mBAAA;wBAAA;0BAAA;QAAgC;IACxC;AACF;AAMO,eAAeP,UACpBQ,GAAoB,EACpBC,KAAgB;IAEhB,IAAIC;IACJ,IAAI;QACFA,cAAcL,IAAAA,kBAAK,EAACG,IAAIG,OAAO,CAAC,eAAe,IAAI;IACrD,EAAE,OAAM;QACND,cAAcL,IAAAA,kBAAK,EAAC;IACtB;IACA,MAAM,EAAEO,IAAI,EAAEC,UAAU,EAAE,GAAGH;IAC7B,MAAMI,WAAWD,WAAWE,OAAO,IAAI;IAEvC,IAAIC;IAEJ,IAAI;QACF,MAAMC,aACJC,QAAQ;QACVF,SAAS,MAAMC,WAAWT,KAAK;YAAEM;YAAUL;QAAM;IACnD,EAAE,OAAOH,GAAG;QACV,IAAIa,IAAAA,gBAAO,EAACb,MAAMA,EAAEM,IAAI,KAAK,oBAAoB;YAC/C,MAAM,qBAAiD,CAAjD,IAAIL,eAAQ,CAAC,KAAK,CAAC,cAAc,EAAEE,MAAM,MAAM,CAAC,GAAhD,qBAAA;uBAAA;4BAAA;8BAAA;YAAgD;QACxD,OAAO;YACL,MAAM,qBAAiC,CAAjC,IAAIF,eAAQ,CAAC,KAAK,iBAAlB,qBAAA;uBAAA;4BAAA;8BAAA;YAAgC;QACxC;IACF;IAEA,MAAMa,OAAOJ,OAAOK,QAAQ;IAE5B,IAAIT,SAAS,sBAAsBA,SAAS,uBAAuB;QACjE,OAAOX,UAAUmB;IACnB,OAAO,IAAIR,SAAS,qCAAqC;QACvD,MAAMU,KAAKJ,QAAQ;QACnB,OAAOI,GAAGC,MAAM,CAACH;IACnB,OAAO;QACL,OAAOA;IACT;AACF"}

frontend/webapp/node_modules/next/dist/server/api-utils/node/try-get-preview-data.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { __ApiPreviewProps } from '../.';
+import type { BaseNextRequest, BaseNextResponse } from '../../base-http';
+import type { PreviewData } from '../../../types';
+export declare function tryGetPreviewData(req: IncomingMessage | BaseNextRequest | Request, res: ServerResponse | BaseNextResponse, options: __ApiPreviewProps, multiZoneDraftMode: boolean): PreviewData;

frontend/webapp/node_modules/next/dist/server/api-utils/node/try-get-preview-data.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "tryGetPreviewData", {
+    enumerable: true,
+    get: function() {
+        return tryGetPreviewData;
+    }
+});
+const _ = require("../.");
+const _index = require("../index");
+const _cookies = require("../../web/spec-extension/cookies");
+const _headers = require("../../web/spec-extension/adapters/headers");
+function tryGetPreviewData(req, res, options, multiZoneDraftMode) {
+    var _cookies_get, _cookies_get1;
+    // if an On-Demand revalidation is being done preview mode
+    // is disabled
+    if (options && (0, _.checkIsOnDemandRevalidate)(req, options).isOnDemandRevalidate) {
+        return false;
+    }
+    // Read cached preview data if present
+    // TODO: use request metadata instead of a symbol
+    if (_index.SYMBOL_PREVIEW_DATA in req) {
+        return req[_index.SYMBOL_PREVIEW_DATA];
+    }
+    const headers = _headers.HeadersAdapter.from(req.headers);
+    const cookies = new _cookies.RequestCookies(headers);
+    const previewModeId = (_cookies_get = cookies.get(_index.COOKIE_NAME_PRERENDER_BYPASS)) == null ? void 0 : _cookies_get.value;
+    const tokenPreviewData = (_cookies_get1 = cookies.get(_index.COOKIE_NAME_PRERENDER_DATA)) == null ? void 0 : _cookies_get1.value;
+    // Case: preview mode cookie set but data cookie is not set
+    if (previewModeId && !tokenPreviewData && previewModeId === options.previewModeId) {
+        // This is "Draft Mode" which doesn't use
+        // previewData, so we return an empty object
+        // for backwards compat with "Preview Mode".
+        const data = {};
+        Object.defineProperty(req, _index.SYMBOL_PREVIEW_DATA, {
+            value: data,
+            enumerable: false
+        });
+        return data;
+    }
+    // Case: neither cookie is set.
+    if (!previewModeId && !tokenPreviewData) {
+        return false;
+    }
+    // Case: one cookie is set, but not the other.
+    if (!previewModeId || !tokenPreviewData) {
+        if (!multiZoneDraftMode) {
+            (0, _index.clearPreviewData)(res);
+        }
+        return false;
+    }
+    // Case: preview session is for an old build.
+    if (previewModeId !== options.previewModeId) {
+        if (!multiZoneDraftMode) {
+            (0, _index.clearPreviewData)(res);
+        }
+        return false;
+    }
+    let encryptedPreviewData;
+    try {
+        const jsonwebtoken = require('next/dist/compiled/jsonwebtoken');
+        encryptedPreviewData = jsonwebtoken.verify(tokenPreviewData, options.previewModeSigningKey);
+    } catch  {
+        // TODO: warn
+        (0, _index.clearPreviewData)(res);
+        return false;
+    }
+    const { decryptWithSecret } = require('../../crypto-utils');
+    const decryptedPreviewData = decryptWithSecret(Buffer.from(options.previewModeEncryptionKey), encryptedPreviewData.data);
+    try {
+        // TODO: strict runtime type checking
+        const data = JSON.parse(decryptedPreviewData);
+        // Cache lookup
+        Object.defineProperty(req, _index.SYMBOL_PREVIEW_DATA, {
+            value: data,
+            enumerable: false
+        });
+        return data;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=try-get-preview-data.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/web.d.ts

@@ -0,0 +1 @@
+export declare function byteLength(payload: string): number;

frontend/webapp/node_modules/next/dist/server/api-utils/web.js

@@ -0,0 +1,17 @@
+// Buffer.byteLength polyfill in the Edge runtime, with only utf8 strings
+// supported at the moment.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "byteLength", {
+    enumerable: true,
+    get: function() {
+        return byteLength;
+    }
+});
+function byteLength(payload) {
+    return new TextEncoder().encode(payload).buffer.byteLength;
+}
+
+//# sourceMappingURL=web.js.map

frontend/webapp/node_modules/next/dist/server/api-utils/web.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/api-utils/web.ts"],"sourcesContent":["// Buffer.byteLength polyfill in the Edge runtime, with only utf8 strings\n// supported at the moment.\nexport function byteLength(payload: string): number {\n  return new TextEncoder().encode(payload).buffer.byteLength\n}\n"],"names":["byteLength","payload","TextEncoder","encode","buffer"],"mappings":"AAAA,yEAAyE;AACzE,2BAA2B;;;;;+BACXA;;;eAAAA;;;AAAT,SAASA,WAAWC,OAAe;IACxC,OAAO,IAAIC,cAAcC,MAAM,CAACF,SAASG,MAAM,CAACJ,UAAU;AAC5D"}

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts

@@ -0,0 +1,2 @@
+import type { ActionAsyncStorage } from './action-async-storage.external';
+export declare const actionAsyncStorageInstance: ActionAsyncStorage;

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage-instance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "actionAsyncStorageInstance", {
+    enumerable: true,
+    get: function() {
+        return actionAsyncStorageInstance;
+    }
+});
+const _asynclocalstorage = require("./async-local-storage");
+const actionAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+
+//# sourceMappingURL=action-async-storage-instance.js.map

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/action-async-storage-instance.ts"],"sourcesContent":["import type { ActionAsyncStorage } from './action-async-storage.external'\nimport { createAsyncLocalStorage } from './async-local-storage'\n\nexport const actionAsyncStorageInstance: ActionAsyncStorage =\n  createAsyncLocalStorage()\n"],"names":["actionAsyncStorageInstance","createAsyncLocalStorage"],"mappings":";;;;+BAGaA;;;eAAAA;;;mCAF2B;AAEjC,MAAMA,6BACXC,IAAAA,0CAAuB"}

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage.external.d.ts

@@ -0,0 +1,8 @@
+import type { AsyncLocalStorage } from 'async_hooks';
+import { actionAsyncStorageInstance } from './action-async-storage-instance';
+export interface ActionStore {
+    readonly isAction?: boolean;
+    readonly isAppRoute?: boolean;
+}
+export type ActionAsyncStorage = AsyncLocalStorage<ActionStore>;
+export { actionAsyncStorageInstance as actionAsyncStorage };

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage.external.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "actionAsyncStorage", {
+    enumerable: true,
+    get: function() {
+        return _actionasyncstorageinstance.actionAsyncStorageInstance;
+    }
+});
+const _actionasyncstorageinstance = require("./action-async-storage-instance");
+
+//# sourceMappingURL=action-async-storage.external.js.map

frontend/webapp/node_modules/next/dist/server/app-render/action-async-storage.external.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/action-async-storage.external.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'async_hooks'\n\n// Share the instance module in the next-shared layer\nimport { actionAsyncStorageInstance } from './action-async-storage-instance' with { 'turbopack-transition': 'next-shared' }\nexport interface ActionStore {\n  readonly isAction?: boolean\n  readonly isAppRoute?: boolean\n}\n\nexport type ActionAsyncStorage = AsyncLocalStorage<ActionStore>\n\nexport { actionAsyncStorageInstance as actionAsyncStorage }\n"],"names":["actionAsyncStorage","actionAsyncStorageInstance"],"mappings":";;;;+BAWuCA;;;eAA9BC,sDAA0B;;;4CARQ"}

frontend/webapp/node_modules/next/dist/server/app-render/action-handler.d.ts

@@ -0,0 +1,43 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import type { SizeLimit } from '../../types';
+import type { RequestStore } from '../app-render/work-unit-async-storage.external';
+import type { AppRenderContext, GenerateFlight } from './app-render';
+import type { AppPageModule } from '../route-modules/app-page/module';
+import type { BaseNextRequest, BaseNextResponse } from '../base-http';
+import RenderResult from '../render-result';
+import type { WorkStore } from '../app-render/work-async-storage.external';
+declare const enum HostType {
+    XForwardedHost = "x-forwarded-host",
+    Host = "host"
+}
+export declare function parseHostHeader(headers: IncomingHttpHeaders, originDomain?: string): {
+    type: HostType;
+    value: string;
+} | undefined;
+type ServerModuleMap = Record<string, {
+    id: string;
+    chunks: string[];
+    name: string;
+}>;
+type ServerActionsConfig = {
+    bodySizeLimit?: SizeLimit;
+    allowedOrigins?: string[];
+};
+export declare function handleAction({ req, res, ComponentMod, serverModuleMap, generateFlight, workStore, requestStore, serverActions, ctx, }: {
+    req: BaseNextRequest;
+    res: BaseNextResponse;
+    ComponentMod: AppPageModule;
+    serverModuleMap: ServerModuleMap;
+    generateFlight: GenerateFlight;
+    workStore: WorkStore;
+    requestStore: RequestStore;
+    serverActions?: ServerActionsConfig;
+    ctx: AppRenderContext;
+}): Promise<undefined | {
+    type: 'not-found';
+} | {
+    type: 'done';
+    result: RenderResult | undefined;
+    formState?: any;
+}>;
+export {};

frontend/webapp/node_modules/next/dist/server/app-render/action-handler.js

@@ -0,0 +1,754 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handleAction: null,
+    parseHostHeader: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handleAction: function() {
+        return handleAction;
+    },
+    parseHostHeader: function() {
+        return parseHostHeader;
+    }
+});
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
+const _redirect = require("../../client/components/redirect");
+const _redirecterror = require("../../client/components/redirect-error");
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
+const _flightrenderresult = require("./flight-render-result");
+const _utils = require("../lib/server-ipc/utils");
+const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
+const _constants = require("../../lib/constants");
+const _serveractionrequestmeta = require("../lib/server-action-request-meta");
+const _csrfprotection = require("./csrf-protection");
+const _log = require("../../build/output/log");
+const _cookies = require("../web/spec-extension/cookies");
+const _headers = require("../web/spec-extension/adapters/headers");
+const _utils1 = require("../web/utils");
+const _actionutils = require("./action-utils");
+const _helpers = require("../base-http/helpers");
+const _redirectstatuscode = require("../../client/components/redirect-status-code");
+const _requeststore = require("../async-storage/request-store");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _revalidationutils = require("../revalidation-utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function formDataFromSearchQueryString(query) {
+    const searchParams = new URLSearchParams(query);
+    const formData = new FormData();
+    for (const [key, value] of searchParams){
+        formData.append(key, value);
+    }
+    return formData;
+}
+function nodeHeadersToRecord(headers) {
+    const record = {};
+    for (const [key, value] of Object.entries(headers)){
+        if (value !== undefined) {
+            record[key] = Array.isArray(value) ? value.join(', ') : `${value}`;
+        }
+    }
+    return record;
+}
+function getForwardedHeaders(req, res) {
+    // Get request headers and cookies
+    const requestHeaders = req.headers;
+    const requestCookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(requestHeaders));
+    // Get response headers and cookies
+    const responseHeaders = res.getHeaders();
+    const responseCookies = new _cookies.ResponseCookies((0, _utils1.fromNodeOutgoingHttpHeaders)(responseHeaders));
+    // Merge request and response headers
+    const mergedHeaders = (0, _utils.filterReqHeaders)({
+        ...nodeHeadersToRecord(requestHeaders),
+        ...nodeHeadersToRecord(responseHeaders)
+    }, _utils.actionsForbiddenHeaders);
+    // Merge cookies into requestCookies, so responseCookies always take precedence
+    // and overwrite/delete those from requestCookies.
+    responseCookies.getAll().forEach((cookie)=>{
+        if (typeof cookie.value === 'undefined') {
+            requestCookies.delete(cookie.name);
+        } else {
+            requestCookies.set(cookie);
+        }
+    });
+    // Update the 'cookie' header with the merged cookies
+    mergedHeaders['cookie'] = requestCookies.toString();
+    // Remove headers that should not be forwarded
+    delete mergedHeaders['transfer-encoding'];
+    return new Headers(mergedHeaders);
+}
+function addRevalidationHeader(res, { workStore, requestStore }) {
+    var _workStore_pendingRevalidatedTags;
+    // If a tag was revalidated, the client router needs to invalidate all the
+    // client router cache as they may be stale. And if a path was revalidated, the
+    // client needs to invalidate all subtrees below that path.
+    // To keep the header size small, we use a tuple of
+    // [[revalidatedPaths], isTagRevalidated ? 1 : 0, isCookieRevalidated ? 1 : 0]
+    // instead of a JSON object.
+    // TODO-APP: Currently the prefetch cache doesn't have subtree information,
+    // so we need to invalidate the entire cache if a path was revalidated.
+    // TODO-APP: Currently paths are treated as tags, so the second element of the tuple
+    // is always empty.
+    const isTagRevalidated = ((_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.length) ? 1 : 0;
+    const isCookieRevalidated = (0, _requestcookies.getModifiedCookieValues)(requestStore.mutableCookies).length ? 1 : 0;
+    res.setHeader('x-action-revalidated', JSON.stringify([
+        [],
+        isTagRevalidated,
+        isCookieRevalidated
+    ]));
+}
+/**
+ * Forwards a server action request to a separate worker. Used when the requested action is not available in the current worker.
+ */ async function createForwardedActionResponse(req, res, host, workerPathname, basePath, workStore) {
+    var _workStore_incrementalCache;
+    if (!host) {
+        throw Object.defineProperty(new Error('Invariant: Missing `host` header from a forwarded Server Actions request.'), "__NEXT_ERROR_CODE", {
+            value: "E226",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const forwardedHeaders = getForwardedHeaders(req, res);
+    // indicate that this action request was forwarded from another worker
+    // we use this to skip rendering the flight tree so that we don't update the UI
+    // with the response from the forwarded worker
+    forwardedHeaders.set('x-action-forwarded', '1');
+    const proto = ((_workStore_incrementalCache = workStore.incrementalCache) == null ? void 0 : _workStore_incrementalCache.requestProtocol) || 'https';
+    // For standalone or the serverful mode, use the internal origin directly
+    // other than the host headers from the request.
+    const origin = process.env.__NEXT_PRIVATE_ORIGIN || `${proto}://${host.value}`;
+    const fetchUrl = new URL(`${origin}${basePath}${workerPathname}`);
+    try {
+        var _response_headers_get;
+        let body;
+        if (// The type check here ensures that `req` is correctly typed, and the
+        // environment variable check provides dead code elimination.
+        process.env.NEXT_RUNTIME === 'edge' && (0, _helpers.isWebNextRequest)(req)) {
+            if (!req.body) {
+                throw Object.defineProperty(new Error('Invariant: missing request body.'), "__NEXT_ERROR_CODE", {
+                    value: "E333",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            body = req.body;
+        } else if (// The type check here ensures that `req` is correctly typed, and the
+        // environment variable check provides dead code elimination.
+        process.env.NEXT_RUNTIME !== 'edge' && (0, _helpers.isNodeNextRequest)(req)) {
+            body = req.stream();
+        } else {
+            throw Object.defineProperty(new Error('Invariant: Unknown request type.'), "__NEXT_ERROR_CODE", {
+                value: "E114",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // Forward the request to the new worker
+        const response = await fetch(fetchUrl, {
+            method: 'POST',
+            body,
+            duplex: 'half',
+            headers: forwardedHeaders,
+            redirect: 'manual',
+            next: {
+                // @ts-ignore
+                internal: 1
+            }
+        });
+        if ((_response_headers_get = response.headers.get('content-type')) == null ? void 0 : _response_headers_get.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER)) {
+            // copy the headers from the redirect response to the response we're sending
+            for (const [key, value] of response.headers){
+                if (!_utils.actionsForbiddenHeaders.includes(key)) {
+                    res.setHeader(key, value);
+                }
+            }
+            return new _flightrenderresult.FlightRenderResult(response.body);
+        } else {
+            var // Since we aren't consuming the response body, we cancel it to avoid memory leaks
+            _response_body;
+            (_response_body = response.body) == null ? void 0 : _response_body.cancel();
+        }
+    } catch (err) {
+        // we couldn't stream the forwarded response, so we'll just return an empty response
+        console.error(`failed to forward action response`, err);
+    }
+    return _renderresult.default.fromStatic('{}');
+}
+/**
+ * Returns the parsed redirect URL if we deem that it is hosted by us.
+ *
+ * We handle both relative and absolute redirect URLs.
+ *
+ * In case the redirect URL is not relative to the application we return `null`.
+ */ function getAppRelativeRedirectUrl(basePath, host, redirectUrl) {
+    if (redirectUrl.startsWith('/') || redirectUrl.startsWith('.')) {
+        // Make sure we are appending the basePath to relative URLS
+        return new URL(`${basePath}${redirectUrl}`, 'http://n');
+    }
+    const parsedRedirectUrl = new URL(redirectUrl);
+    if ((host == null ? void 0 : host.value) !== parsedRedirectUrl.host) {
+        return null;
+    }
+    // At this point the hosts are the same, just confirm we
+    // are routing to a path underneath the `basePath`
+    return parsedRedirectUrl.pathname.startsWith(basePath) ? parsedRedirectUrl : null;
+}
+async function createRedirectRenderResult(req, res, originalHost, redirectUrl, redirectType, basePath, workStore) {
+    res.setHeader('x-action-redirect', `${redirectUrl};${redirectType}`);
+    // If we're redirecting to another route of this Next.js application, we'll
+    // try to stream the response from the other worker path. When that works,
+    // we can save an extra roundtrip and avoid a full page reload.
+    // When the redirect URL starts with a `/` or is to the same host, under the
+    // `basePath` we treat it as an app-relative redirect;
+    const appRelativeRedirectUrl = getAppRelativeRedirectUrl(basePath, originalHost, redirectUrl);
+    if (appRelativeRedirectUrl) {
+        var _workStore_incrementalCache;
+        if (!originalHost) {
+            throw Object.defineProperty(new Error('Invariant: Missing `host` header from a forwarded Server Actions request.'), "__NEXT_ERROR_CODE", {
+                value: "E226",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const forwardedHeaders = getForwardedHeaders(req, res);
+        forwardedHeaders.set(_approuterheaders.RSC_HEADER, '1');
+        const proto = ((_workStore_incrementalCache = workStore.incrementalCache) == null ? void 0 : _workStore_incrementalCache.requestProtocol) || 'https';
+        // For standalone or the serverful mode, use the internal origin directly
+        // other than the host headers from the request.
+        const origin = process.env.__NEXT_PRIVATE_ORIGIN || `${proto}://${originalHost.value}`;
+        const fetchUrl = new URL(`${origin}${appRelativeRedirectUrl.pathname}${appRelativeRedirectUrl.search}`);
+        if (workStore.pendingRevalidatedTags) {
+            var _workStore_incrementalCache_prerenderManifest_preview, _workStore_incrementalCache_prerenderManifest, _workStore_incrementalCache1;
+            forwardedHeaders.set(_constants.NEXT_CACHE_REVALIDATED_TAGS_HEADER, workStore.pendingRevalidatedTags.join(','));
+            forwardedHeaders.set(_constants.NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER, ((_workStore_incrementalCache1 = workStore.incrementalCache) == null ? void 0 : (_workStore_incrementalCache_prerenderManifest = _workStore_incrementalCache1.prerenderManifest) == null ? void 0 : (_workStore_incrementalCache_prerenderManifest_preview = _workStore_incrementalCache_prerenderManifest.preview) == null ? void 0 : _workStore_incrementalCache_prerenderManifest_preview.previewModeId) || '');
+        }
+        // Ensures that when the path was revalidated we don't return a partial response on redirects
+        forwardedHeaders.delete(_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER);
+        // When an action follows a redirect, it's no longer handling an action: it's just a normal RSC request
+        // to the requested URL. We should remove the `next-action` header so that it's not treated as an action
+        forwardedHeaders.delete(_approuterheaders.ACTION_HEADER);
+        try {
+            var _response_headers_get;
+            const response = await fetch(fetchUrl, {
+                method: 'GET',
+                headers: forwardedHeaders,
+                next: {
+                    // @ts-ignore
+                    internal: 1
+                }
+            });
+            if ((_response_headers_get = response.headers.get('content-type')) == null ? void 0 : _response_headers_get.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER)) {
+                // copy the headers from the redirect response to the response we're sending
+                for (const [key, value] of response.headers){
+                    if (!_utils.actionsForbiddenHeaders.includes(key)) {
+                        res.setHeader(key, value);
+                    }
+                }
+                return new _flightrenderresult.FlightRenderResult(response.body);
+            } else {
+                var // Since we aren't consuming the response body, we cancel it to avoid memory leaks
+                _response_body;
+                (_response_body = response.body) == null ? void 0 : _response_body.cancel();
+            }
+        } catch (err) {
+            // we couldn't stream the redirect response, so we'll just do a normal redirect
+            console.error(`failed to get redirect response`, err);
+        }
+    }
+    return _renderresult.default.fromStatic('{}');
+}
+/**
+ * Ensures the value of the header can't create long logs.
+ */ function limitUntrustedHeaderValueForLogs(value) {
+    return value.length > 100 ? value.slice(0, 100) + '...' : value;
+}
+function parseHostHeader(headers, originDomain) {
+    var _forwardedHostHeader_split_, _forwardedHostHeader_split;
+    const forwardedHostHeader = headers['x-forwarded-host'];
+    const forwardedHostHeaderValue = forwardedHostHeader && Array.isArray(forwardedHostHeader) ? forwardedHostHeader[0] : forwardedHostHeader == null ? void 0 : (_forwardedHostHeader_split = forwardedHostHeader.split(',')) == null ? void 0 : (_forwardedHostHeader_split_ = _forwardedHostHeader_split[0]) == null ? void 0 : _forwardedHostHeader_split_.trim();
+    const hostHeader = headers['host'];
+    if (originDomain) {
+        return forwardedHostHeaderValue === originDomain ? {
+            type: "x-forwarded-host",
+            value: forwardedHostHeaderValue
+        } : hostHeader === originDomain ? {
+            type: "host",
+            value: hostHeader
+        } : undefined;
+    }
+    return forwardedHostHeaderValue ? {
+        type: "x-forwarded-host",
+        value: forwardedHostHeaderValue
+    } : hostHeader ? {
+        type: "host",
+        value: hostHeader
+    } : undefined;
+}
+async function handleAction({ req, res, ComponentMod, serverModuleMap, generateFlight, workStore, requestStore, serverActions, ctx }) {
+    const contentType = req.headers['content-type'];
+    const { serverActionsManifest, page } = ctx.renderOpts;
+    const { actionId, isURLEncodedAction, isMultipartAction, isFetchAction, isPossibleServerAction } = (0, _serveractionrequestmeta.getServerActionRequestMetadata)(req);
+    // If it can't be a Server Action, skip handling.
+    // Note that this can be a false positive -- any multipart/urlencoded POST can get us here,
+    // But won't know if it's an MPA action or not until we call `decodeAction` below.
+    if (!isPossibleServerAction) {
+        return;
+    }
+    if (workStore.isStaticGeneration) {
+        throw Object.defineProperty(new Error("Invariant: server actions can't be handled during static rendering"), "__NEXT_ERROR_CODE", {
+            value: "E359",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    let temporaryReferences;
+    const finalizeAndGenerateFlight = (...args)=>{
+        // When we switch to the render phase, cookies() will return
+        // `workUnitStore.cookies` instead of `workUnitStore.userspaceMutableCookies`.
+        // We want the render to see any cookie writes that we performed during the action,
+        // so we need to update the immutable cookies to reflect the changes.
+        (0, _requeststore.synchronizeMutableCookies)(requestStore);
+        // The server action might have toggled draft mode, so we need to reflect
+        // that in the work store to be up-to-date for subsequent rendering.
+        workStore.isDraftMode = requestStore.draftMode.isEnabled;
+        return generateFlight(...args);
+    };
+    // When running actions the default is no-store, you can still `cache: 'force-cache'`
+    workStore.fetchCache = 'default-no-store';
+    const originDomain = typeof req.headers['origin'] === 'string' ? new URL(req.headers['origin']).host : undefined;
+    const host = parseHostHeader(req.headers);
+    let warning = undefined;
+    function warnBadServerActionRequest() {
+        if (warning) {
+            (0, _log.warn)(warning);
+        }
+    }
+    // This is to prevent CSRF attacks. If `x-forwarded-host` is set, we need to
+    // ensure that the request is coming from the same host.
+    if (!originDomain) {
+        // This might be an old browser that doesn't send `host` header. We ignore
+        // this case.
+        warning = 'Missing `origin` header from a forwarded Server Actions request.';
+    } else if (!host || originDomain !== host.value) {
+        // If the customer sets a list of allowed origins, we'll allow the request.
+        // These are considered safe but might be different from forwarded host set
+        // by the infra (i.e. reverse proxies).
+        if ((0, _csrfprotection.isCsrfOriginAllowed)(originDomain, serverActions == null ? void 0 : serverActions.allowedOrigins)) {
+        // Ignore it
+        } else {
+            if (host) {
+                // This seems to be an CSRF attack. We should not proceed the action.
+                console.error(`\`${host.type}\` header with value \`${limitUntrustedHeaderValueForLogs(host.value)}\` does not match \`origin\` header with value \`${limitUntrustedHeaderValueForLogs(originDomain)}\` from a forwarded Server Actions request. Aborting the action.`);
+            } else {
+                // This is an attack. We should not proceed the action.
+                console.error(`\`x-forwarded-host\` or \`host\` headers are not provided. One of these is needed to compare the \`origin\` header from a forwarded Server Actions request. Aborting the action.`);
+            }
+            const error = Object.defineProperty(new Error('Invalid Server Actions request.'), "__NEXT_ERROR_CODE", {
+                value: "E80",
+                enumerable: false,
+                configurable: true
+            });
+            if (isFetchAction) {
+                res.statusCode = 500;
+                await (0, _revalidationutils.executeRevalidates)(workStore);
+                const promise = Promise.reject(error);
+                try {
+                    // we need to await the promise to trigger the rejection early
+                    // so that it's already handled by the time we call
+                    // the RSC runtime. Otherwise, it will throw an unhandled
+                    // promise rejection error in the renderer.
+                    await promise;
+                } catch  {
+                // swallow error, it's gonna be handled on the client
+                }
+                return {
+                    type: 'done',
+                    result: await finalizeAndGenerateFlight(req, ctx, requestStore, {
+                        actionResult: promise,
+                        // if the page was not revalidated, we can skip the rendering the flight tree
+                        skipFlight: !workStore.pathWasRevalidated,
+                        temporaryReferences
+                    })
+                };
+            }
+            throw error;
+        }
+    }
+    // ensure we avoid caching server actions unexpectedly
+    res.setHeader('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate');
+    let boundActionArguments = [];
+    const { actionAsyncStorage } = ComponentMod;
+    let actionResult;
+    let formState;
+    let actionModId;
+    const actionWasForwarded = Boolean(req.headers['x-action-forwarded']);
+    if (actionId) {
+        const forwardedWorker = (0, _actionutils.selectWorkerForForwarding)(actionId, page, serverActionsManifest);
+        // If forwardedWorker is truthy, it means there isn't a worker for the action
+        // in the current handler, so we forward the request to a worker that has the action.
+        if (forwardedWorker) {
+            return {
+                type: 'done',
+                result: await createForwardedActionResponse(req, res, host, forwardedWorker, ctx.renderOpts.basePath, workStore)
+            };
+        }
+    }
+    try {
+        await actionAsyncStorage.run({
+            isAction: true
+        }, async ()=>{
+            if (// The type check here ensures that `req` is correctly typed, and the
+            // environment variable check provides dead code elimination.
+            process.env.NEXT_RUNTIME === 'edge' && (0, _helpers.isWebNextRequest)(req)) {
+                if (!req.body) {
+                    throw Object.defineProperty(new Error('invariant: Missing request body.'), "__NEXT_ERROR_CODE", {
+                        value: "E364",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // TODO: add body limit
+                // Use react-server-dom-webpack/server.edge
+                const { createTemporaryReferenceSet, decodeReply, decodeAction, decodeFormState } = ComponentMod;
+                temporaryReferences = createTemporaryReferenceSet();
+                if (isMultipartAction) {
+                    // TODO-APP: Add streaming support
+                    const formData = await req.request.formData();
+                    if (isFetchAction) {
+                        boundActionArguments = await decodeReply(formData, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    } else {
+                        const action = await decodeAction(formData, serverModuleMap);
+                        if (typeof action === 'function') {
+                            // Only warn if it's a server action, otherwise skip for other post requests
+                            warnBadServerActionRequest();
+                            let actionReturnedState;
+                            requestStore.phase = 'action';
+                            try {
+                                actionReturnedState = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, action);
+                            } finally{
+                                requestStore.phase = 'render';
+                            }
+                            formState = await decodeFormState(actionReturnedState, formData, serverModuleMap);
+                        }
+                        // Skip the fetch path
+                        return;
+                    }
+                } else {
+                    try {
+                        actionModId = getActionModIdOrError(actionId, serverModuleMap);
+                    } catch (err) {
+                        if (actionId !== null) {
+                            console.error(err);
+                        }
+                        return {
+                            type: 'not-found'
+                        };
+                    }
+                    const chunks = [];
+                    const reader = req.body.getReader();
+                    while(true){
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
+                        }
+                        chunks.push(value);
+                    }
+                    const actionData = Buffer.concat(chunks).toString('utf-8');
+                    if (isURLEncodedAction) {
+                        const formData = formDataFromSearchQueryString(actionData);
+                        boundActionArguments = await decodeReply(formData, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    } else {
+                        boundActionArguments = await decodeReply(actionData, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    }
+                }
+            } else if (// The type check here ensures that `req` is correctly typed, and the
+            // environment variable check provides dead code elimination.
+            process.env.NEXT_RUNTIME !== 'edge' && (0, _helpers.isNodeNextRequest)(req)) {
+                // Use react-server-dom-webpack/server.node which supports streaming
+                const { createTemporaryReferenceSet, decodeReply, decodeReplyFromBusboy, decodeAction, decodeFormState } = require(`./react-server.node`);
+                temporaryReferences = createTemporaryReferenceSet();
+                const { Transform } = require('node:stream');
+                const defaultBodySizeLimit = '1 MB';
+                const bodySizeLimit = (serverActions == null ? void 0 : serverActions.bodySizeLimit) ?? defaultBodySizeLimit;
+                const bodySizeLimitBytes = bodySizeLimit !== defaultBodySizeLimit ? require('next/dist/compiled/bytes').parse(bodySizeLimit) : 1024 * 1024 // 1 MB
+                ;
+                let size = 0;
+                const body = req.body.pipe(new Transform({
+                    transform (chunk, encoding, callback) {
+                        size += Buffer.byteLength(chunk, encoding);
+                        if (size > bodySizeLimitBytes) {
+                            const { ApiError } = require('../api-utils');
+                            callback(Object.defineProperty(new ApiError(413, `Body exceeded ${bodySizeLimit} limit.
+                To configure the body size limit for Server Actions, see: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit`), "__NEXT_ERROR_CODE", {
+                                value: "E394",
+                                enumerable: false,
+                                configurable: true
+                            }));
+                            return;
+                        }
+                        callback(null, chunk);
+                    }
+                }));
+                if (isMultipartAction) {
+                    if (isFetchAction) {
+                        const busboy = require('busboy')({
+                            defParamCharset: 'utf8',
+                            headers: req.headers,
+                            limits: {
+                                fieldSize: bodySizeLimitBytes
+                            }
+                        });
+                        body.pipe(busboy);
+                        boundActionArguments = await decodeReplyFromBusboy(busboy, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    } else {
+                        // React doesn't yet publish a busboy version of decodeAction
+                        // so we polyfill the parsing of FormData.
+                        const fakeRequest = new Request('http://localhost', {
+                            method: 'POST',
+                            // @ts-expect-error
+                            headers: {
+                                'Content-Type': contentType
+                            },
+                            body: new ReadableStream({
+                                start: (controller)=>{
+                                    body.on('data', (chunk)=>{
+                                        controller.enqueue(new Uint8Array(chunk));
+                                    });
+                                    body.on('end', ()=>{
+                                        controller.close();
+                                    });
+                                    body.on('error', (err)=>{
+                                        controller.error(err);
+                                    });
+                                }
+                            }),
+                            duplex: 'half'
+                        });
+                        const formData = await fakeRequest.formData();
+                        const action = await decodeAction(formData, serverModuleMap);
+                        if (typeof action === 'function') {
+                            // Only warn if it's a server action, otherwise skip for other post requests
+                            warnBadServerActionRequest();
+                            let actionReturnedState;
+                            requestStore.phase = 'action';
+                            try {
+                                actionReturnedState = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, action);
+                            } finally{
+                                requestStore.phase = 'render';
+                            }
+                            formState = await decodeFormState(actionReturnedState, formData, serverModuleMap);
+                        }
+                        // Skip the fetch path
+                        return;
+                    }
+                } else {
+                    try {
+                        actionModId = getActionModIdOrError(actionId, serverModuleMap);
+                    } catch (err) {
+                        if (actionId !== null) {
+                            console.error(err);
+                        }
+                        return {
+                            type: 'not-found'
+                        };
+                    }
+                    const chunks = [];
+                    for await (const chunk of req.body){
+                        chunks.push(Buffer.from(chunk));
+                    }
+                    const actionData = Buffer.concat(chunks).toString('utf-8');
+                    if (isURLEncodedAction) {
+                        const formData = formDataFromSearchQueryString(actionData);
+                        boundActionArguments = await decodeReply(formData, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    } else {
+                        boundActionArguments = await decodeReply(actionData, serverModuleMap, {
+                            temporaryReferences
+                        });
+                    }
+                }
+            } else {
+                throw Object.defineProperty(new Error('Invariant: Unknown request type.'), "__NEXT_ERROR_CODE", {
+                    value: "E114",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            // actions.js
+            // app/page.js
+            //   action worker1
+            //     appRender1
+            // app/foo/page.js
+            //   action worker2
+            //     appRender
+            // / -> fire action -> POST / -> appRender1 -> modId for the action file
+            // /foo -> fire action -> POST /foo -> appRender2 -> modId for the action file
+            try {
+                actionModId = actionModId ?? getActionModIdOrError(actionId, serverModuleMap);
+            } catch (err) {
+                if (actionId !== null) {
+                    console.error(err);
+                }
+                return {
+                    type: 'not-found'
+                };
+            }
+            const actionMod = await ComponentMod.__next_app__.require(actionModId);
+            const actionHandler = actionMod[// `actionId` must exist if we got here, as otherwise we would have thrown an error above
+            actionId];
+            let returnVal;
+            requestStore.phase = 'action';
+            try {
+                returnVal = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>actionHandler.apply(null, boundActionArguments));
+            } finally{
+                requestStore.phase = 'render';
+            }
+            // For form actions, we need to continue rendering the page.
+            if (isFetchAction) {
+                await (0, _revalidationutils.executeRevalidates)(workStore);
+                addRevalidationHeader(res, {
+                    workStore,
+                    requestStore
+                });
+                actionResult = await finalizeAndGenerateFlight(req, ctx, requestStore, {
+                    actionResult: Promise.resolve(returnVal),
+                    // if the page was not revalidated, or if the action was forwarded from another worker, we can skip the rendering the flight tree
+                    skipFlight: !workStore.pathWasRevalidated || actionWasForwarded,
+                    temporaryReferences
+                });
+            }
+        });
+        return {
+            type: 'done',
+            result: actionResult,
+            formState
+        };
+    } catch (err) {
+        if ((0, _redirecterror.isRedirectError)(err)) {
+            const redirectUrl = (0, _redirect.getURLFromRedirectError)(err);
+            const redirectType = (0, _redirect.getRedirectTypeFromError)(err);
+            await (0, _revalidationutils.executeRevalidates)(workStore);
+            addRevalidationHeader(res, {
+                workStore,
+                requestStore
+            });
+            // if it's a fetch action, we'll set the status code for logging/debugging purposes
+            // but we won't set a Location header, as the redirect will be handled by the client router
+            res.statusCode = _redirectstatuscode.RedirectStatusCode.SeeOther;
+            if (isFetchAction) {
+                return {
+                    type: 'done',
+                    result: await createRedirectRenderResult(req, res, host, redirectUrl, redirectType, ctx.renderOpts.basePath, workStore)
+                };
+            }
+            res.setHeader('Location', redirectUrl);
+            return {
+                type: 'done',
+                result: _renderresult.default.fromStatic('')
+            };
+        } else if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            await (0, _revalidationutils.executeRevalidates)(workStore);
+            addRevalidationHeader(res, {
+                workStore,
+                requestStore
+            });
+            if (isFetchAction) {
+                const promise = Promise.reject(err);
+                try {
+                    // we need to await the promise to trigger the rejection early
+                    // so that it's already handled by the time we call
+                    // the RSC runtime. Otherwise, it will throw an unhandled
+                    // promise rejection error in the renderer.
+                    await promise;
+                } catch  {
+                // swallow error, it's gonna be handled on the client
+                }
+                return {
+                    type: 'done',
+                    result: await finalizeAndGenerateFlight(req, ctx, requestStore, {
+                        skipFlight: false,
+                        actionResult: promise,
+                        temporaryReferences
+                    })
+                };
+            }
+            return {
+                type: 'not-found'
+            };
+        }
+        if (isFetchAction) {
+            res.statusCode = 500;
+            await (0, _revalidationutils.executeRevalidates)(workStore);
+            const promise = Promise.reject(err);
+            try {
+                // we need to await the promise to trigger the rejection early
+                // so that it's already handled by the time we call
+                // the RSC runtime. Otherwise, it will throw an unhandled
+                // promise rejection error in the renderer.
+                await promise;
+            } catch  {
+            // swallow error, it's gonna be handled on the client
+            }
+            return {
+                type: 'done',
+                result: await generateFlight(req, ctx, requestStore, {
+                    actionResult: promise,
+                    // if the page was not revalidated, or if the action was forwarded from another worker, we can skip the rendering the flight tree
+                    skipFlight: !workStore.pathWasRevalidated || actionWasForwarded,
+                    temporaryReferences
+                })
+            };
+        }
+        throw err;
+    }
+}
+/**
+ * Attempts to find the module ID for the action from the module map. When this fails, it could be a deployment skew where
+ * the action came from a different deployment. It could also simply be an invalid POST request that is not a server action.
+ * In either case, we'll throw an error to be handled by the caller.
+ */ function getActionModIdOrError(actionId, serverModuleMap) {
+    var _serverModuleMap_actionId;
+    // if we're missing the action ID header, we can't do any further processing
+    if (!actionId) {
+        throw Object.defineProperty(new _invarianterror.InvariantError("Missing 'next-action' header."), "__NEXT_ERROR_CODE", {
+            value: "E664",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const actionModId = (_serverModuleMap_actionId = serverModuleMap[actionId]) == null ? void 0 : _serverModuleMap_actionId.id;
+    if (!actionModId) {
+        throw Object.defineProperty(new Error(`Failed to find Server Action "${actionId}". This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
+            value: "E665",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return actionModId;
+}
+
+//# sourceMappingURL=action-handler.js.map

frontend/webapp/node_modules/next/dist/server/app-render/action-utils.d.ts

@@ -0,0 +1,9 @@
+import type { ActionManifest } from '../../build/webpack/plugins/flight-client-entry-plugin';
+export declare function createServerModuleMap({ serverActionsManifest, }: {
+    serverActionsManifest: ActionManifest;
+}): {};
+/**
+ * Checks if the requested action has a worker for the current page.
+ * If not, it returns the first worker that has a handler for the action.
+ */
+export declare function selectWorkerForForwarding(actionId: string, pageName: string, serverActionsManifest: ActionManifest): string | undefined;

frontend/webapp/node_modules/next/dist/server/app-render/action-utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createServerModuleMap: null,
+    selectWorkerForForwarding: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createServerModuleMap: function() {
+        return createServerModuleMap;
+    },
+    selectWorkerForForwarding: function() {
+        return selectWorkerForForwarding;
+    }
+});
+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");
+function createServerModuleMap({ serverActionsManifest }) {
+    return new Proxy({}, {
+        get: (_, id)=>{
+            var _serverActionsManifest__id, _serverActionsManifest_;
+            const workers = (_serverActionsManifest_ = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_serverActionsManifest__id = _serverActionsManifest_[id]) == null ? void 0 : _serverActionsManifest__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
+            };
+        }
+    });
+}
+function selectWorkerForForwarding(actionId, pageName, serverActionsManifest) {
+    var _serverActionsManifest__actionId;
+    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
+    const workerName = normalizeWorkerPageName(pageName);
+    // no workers, nothing to forward to
+    if (!workers) return;
+    // if there is a worker for this page, no need to forward it.
+    if (workers[workerName]) {
+        return;
+    }
+    // otherwise, grab the first worker that has a handler for this action id
+    return denormalizeWorkerPageName(Object.keys(workers)[0]);
+}
+/**
+ * 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'));
+}
+
+//# sourceMappingURL=action-utils.js.map

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage-instance.d.ts

@@ -0,0 +1,2 @@
+import type { AfterTaskAsyncStorage } from './after-task-async-storage.external';
+export declare const afterTaskAsyncStorageInstance: AfterTaskAsyncStorage;

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
+    enumerable: true,
+    get: function() {
+        return afterTaskAsyncStorageInstance;
+    }
+});
+const _asynclocalstorage = require("./async-local-storage");
+const afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+
+//# sourceMappingURL=after-task-async-storage-instance.js.map

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/after-task-async-storage-instance.ts"],"sourcesContent":["import type { AfterTaskAsyncStorage } from './after-task-async-storage.external'\nimport { createAsyncLocalStorage } from './async-local-storage'\n\nexport const afterTaskAsyncStorageInstance: AfterTaskAsyncStorage =\n  createAsyncLocalStorage()\n"],"names":["afterTaskAsyncStorageInstance","createAsyncLocalStorage"],"mappings":";;;;+BAGaA;;;eAAAA;;;mCAF2B;AAEjC,MAAMA,gCACXC,IAAAA,0CAAuB"}

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage.external.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncLocalStorage } from 'async_hooks';
+import { afterTaskAsyncStorageInstance as afterTaskAsyncStorage } from './after-task-async-storage-instance';
+import type { WorkUnitStore } from './work-unit-async-storage.external';
+export interface AfterTaskStore {
+    /** The phase in which the topmost `after` was called.
+     *
+     * NOTE: Can be undefined when running `generateStaticParams`,
+     * where we only have a `workStore`, no `workUnitStore`.
+     */
+    readonly rootTaskSpawnPhase: WorkUnitStore['phase'] | undefined;
+}
+export type AfterTaskAsyncStorage = AsyncLocalStorage<AfterTaskStore>;
+export { afterTaskAsyncStorage };

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage.external.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "afterTaskAsyncStorage", {
+    enumerable: true,
+    get: function() {
+        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
+    }
+});
+const _aftertaskasyncstorageinstance = require("./after-task-async-storage-instance");
+
+//# sourceMappingURL=after-task-async-storage.external.js.map

frontend/webapp/node_modules/next/dist/server/app-render/after-task-async-storage.external.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/after-task-async-storage.external.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'async_hooks'\n\n// Share the instance module in the next-shared layer\nimport { afterTaskAsyncStorageInstance as afterTaskAsyncStorage } from './after-task-async-storage-instance' with { 'turbopack-transition': 'next-shared' }\nimport type { WorkUnitStore } from './work-unit-async-storage.external'\n\nexport interface AfterTaskStore {\n  /** The phase in which the topmost `after` was called.\n   *\n   * NOTE: Can be undefined when running `generateStaticParams`,\n   * where we only have a `workStore`, no `workUnitStore`.\n   */\n  readonly rootTaskSpawnPhase: WorkUnitStore['phase'] | undefined\n}\n\nexport type AfterTaskAsyncStorage = AsyncLocalStorage<AfterTaskStore>\n\nexport { afterTaskAsyncStorage }\n"],"names":["afterTaskAsyncStorage"],"mappings":";;;;+BAiBSA;;;eAAAA,4DAAqB;;;+CAdyC"}

frontend/webapp/node_modules/next/dist/server/app-render/app-render-prerender-utils.d.ts

@@ -0,0 +1,66 @@
+/**
+ * This is a utility function to make scheduling sequential tasks that run back to back easier.
+ * We schedule on the same queue (setImmediate) at the same time to ensure no other events can sneak in between.
+ */
+export declare function prerenderAndAbortInSequentialTasks<R>(prerender: () => Promise<R>, abort: () => void): Promise<R>;
+export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, finalPhase: () => void): Promise<ServerPrerenderStreamResult>;
+export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, secondPhase: () => void, finalPhase: () => void): Promise<ServerPrerenderStreamResult>;
+export declare function prerenderServerWithPhases(signal: AbortSignal, render: () => ReadableStream<Uint8Array>, secondPhase: () => void, thirdPhase: () => void, ...remainingPhases: Array<() => void>): Promise<ServerPrerenderStreamResult>;
+export declare class ServerPrerenderStreamResult {
+    private currentChunks;
+    private chunksByPhase;
+    private trailingChunks;
+    private status;
+    private reason;
+    constructor(stream: ReadableStream<Uint8Array>);
+    markPhase(): void;
+    markComplete(): void;
+    markInterrupted(): void;
+    /**
+     * Returns a stream which only releases chunks when `releasePhase` is called. This stream will never "complete" because
+     * we rely upon the stream remaining open when prerendering to avoid triggering errors for incomplete chunks in the client.
+     *
+     * asPhasedStream is expected to be called once per result however it is safe to call multiple times as long as we have not
+     * transferred the underlying data. Generally this will only happen when streaming to a response
+     */
+    asPhasedStream(): PhasedStream<Uint8Array<ArrayBufferLike>>;
+    /**
+     * Returns a stream which will release all chunks immediately. This stream will "complete" synchronously. It should be used outside
+     * of render use cases like loading client chunks ahead of SSR or writing the streamed content to disk.
+     */
+    asStream(): ReadableStream<any>;
+}
+declare class PhasedStream<T> extends ReadableStream<T> {
+    private nextPhase;
+    private chunksByPhase;
+    private destination;
+    constructor(chunksByPhase: Array<Array<T>>);
+    releasePhase(): void;
+    assertExhausted(): void;
+}
+export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, finalPhase: () => void): Promise<T>;
+export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, secondPhase: () => void, finalPhase: () => void): Promise<T>;
+export declare function prerenderClientWithPhases<T>(render: () => Promise<T>, secondPhase: () => void, thirdPhase: () => void, ...remainingPhases: Array<() => void>): Promise<T>;
+export declare class ReactServerResult {
+    private _stream;
+    constructor(stream: ReadableStream<Uint8Array>);
+    tee(): ReadableStream<Uint8Array<ArrayBufferLike>>;
+    consume(): ReadableStream<Uint8Array<ArrayBufferLike>>;
+}
+export type ReactServerPrerenderResolveToType = {
+    prelude: ReadableStream<Uint8Array>;
+};
+export declare function createReactServerPrerenderResult(underlying: Promise<ReactServerPrerenderResolveToType>): Promise<ReactServerPrerenderResult>;
+export declare function createReactServerPrerenderResultFromRender(underlying: ReadableStream<Uint8Array>): Promise<ReactServerPrerenderResult>;
+export declare class ReactServerPrerenderResult {
+    private _chunks;
+    private assertChunks;
+    private consumeChunks;
+    consume(): void;
+    constructor(chunks: Array<Uint8Array>);
+    asUnclosingStream(): ReadableStream<Uint8Array>;
+    consumeAsUnclosingStream(): ReadableStream<Uint8Array>;
+    asStream(): ReadableStream<Uint8Array>;
+    consumeAsStream(): ReadableStream<Uint8Array>;
+}
+export {};

frontend/webapp/node_modules/next/dist/server/app-render/app-render-prerender-utils.js

@@ -0,0 +1,441 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ReactServerPrerenderResult: null,
+    ReactServerResult: null,
+    ServerPrerenderStreamResult: null,
+    createReactServerPrerenderResult: null,
+    createReactServerPrerenderResultFromRender: null,
+    prerenderAndAbortInSequentialTasks: null,
+    prerenderClientWithPhases: null,
+    prerenderServerWithPhases: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ReactServerPrerenderResult: function() {
+        return ReactServerPrerenderResult;
+    },
+    ReactServerResult: function() {
+        return ReactServerResult;
+    },
+    ServerPrerenderStreamResult: function() {
+        return ServerPrerenderStreamResult;
+    },
+    createReactServerPrerenderResult: function() {
+        return createReactServerPrerenderResult;
+    },
+    createReactServerPrerenderResultFromRender: function() {
+        return createReactServerPrerenderResultFromRender;
+    },
+    prerenderAndAbortInSequentialTasks: function() {
+        return prerenderAndAbortInSequentialTasks;
+    },
+    prerenderClientWithPhases: function() {
+        return prerenderClientWithPhases;
+    },
+    prerenderServerWithPhases: function() {
+        return prerenderServerWithPhases;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _dynamicrendering = require("./dynamic-rendering");
+function prerenderAndAbortInSequentialTasks(prerender, abort) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E538",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setImmediate(()=>{
+                try {
+                    pendingResult = prerender();
+                    pendingResult.catch(()=>{});
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            setImmediate(()=>{
+                abort();
+                resolve(pendingResult);
+            });
+        });
+    }
+}
+function prerenderServerWithPhases(signal, render, ...remainingPhases) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E538",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let result;
+            signal.addEventListener('abort', ()=>{
+                if ((0, _dynamicrendering.isPrerenderInterruptedError)(signal.reason)) {
+                    result.markInterrupted();
+                } else {
+                    result.markComplete();
+                }
+            }, {
+                once: true
+            });
+            setImmediate(()=>{
+                try {
+                    result = new ServerPrerenderStreamResult(render());
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            function runFinalTask() {
+                try {
+                    if (result) {
+                        result.markComplete();
+                        this();
+                    }
+                    resolve(result);
+                } catch (err) {
+                    reject(err);
+                }
+            }
+            function runNextTask() {
+                try {
+                    if (result) {
+                        result.markPhase();
+                        this();
+                    }
+                } catch (err) {
+                    reject(err);
+                }
+            }
+            let i = 0;
+            for(; i < remainingPhases.length - 1; i++){
+                const phase = remainingPhases[i];
+                setImmediate(runNextTask.bind(phase));
+            }
+            if (remainingPhases[i]) {
+                const finalPhase = remainingPhases[i];
+                setImmediate(runFinalTask.bind(finalPhase));
+            }
+        });
+    }
+}
+const PENDING = 0;
+const COMPLETE = 1;
+const INTERRUPTED = 2;
+const ERRORED = 3;
+class ServerPrerenderStreamResult {
+    constructor(stream){
+        this.status = PENDING;
+        this.reason = null;
+        this.trailingChunks = [];
+        this.currentChunks = [];
+        this.chunksByPhase = [
+            this.currentChunks
+        ];
+        const reader = stream.getReader();
+        const progress = ({ done, value })=>{
+            if (done) {
+                if (this.status === PENDING) {
+                    this.status = COMPLETE;
+                }
+                return;
+            }
+            if (this.status === PENDING || this.status === INTERRUPTED) {
+                this.currentChunks.push(value);
+            } else {
+                this.trailingChunks.push(value);
+            }
+            reader.read().then(progress, error);
+        };
+        const error = (reason)=>{
+            this.status = ERRORED;
+            this.reason = reason;
+        };
+        reader.read().then(progress, error);
+    }
+    markPhase() {
+        this.currentChunks = [];
+        this.chunksByPhase.push(this.currentChunks);
+    }
+    markComplete() {
+        if (this.status === PENDING) {
+            this.status = COMPLETE;
+        }
+    }
+    markInterrupted() {
+        this.status = INTERRUPTED;
+    }
+    /**
+   * Returns a stream which only releases chunks when `releasePhase` is called. This stream will never "complete" because
+   * we rely upon the stream remaining open when prerendering to avoid triggering errors for incomplete chunks in the client.
+   *
+   * asPhasedStream is expected to be called once per result however it is safe to call multiple times as long as we have not
+   * transferred the underlying data. Generally this will only happen when streaming to a response
+   */ asPhasedStream() {
+        switch(this.status){
+            case COMPLETE:
+            case INTERRUPTED:
+                return new PhasedStream(this.chunksByPhase);
+            default:
+                throw Object.defineProperty(new _invarianterror.InvariantError(`ServerPrerenderStreamResult cannot be consumed as a stream because it is not yet complete. status: ${this.status}`), "__NEXT_ERROR_CODE", {
+                    value: "E612",
+                    enumerable: false,
+                    configurable: true
+                });
+        }
+    }
+    /**
+   * Returns a stream which will release all chunks immediately. This stream will "complete" synchronously. It should be used outside
+   * of render use cases like loading client chunks ahead of SSR or writing the streamed content to disk.
+   */ asStream() {
+        switch(this.status){
+            case COMPLETE:
+            case INTERRUPTED:
+                const chunksByPhase = this.chunksByPhase;
+                const trailingChunks = this.trailingChunks;
+                return new ReadableStream({
+                    start (controller) {
+                        for(let i = 0; i < chunksByPhase.length; i++){
+                            const chunks = chunksByPhase[i];
+                            for(let j = 0; j < chunks.length; j++){
+                                controller.enqueue(chunks[j]);
+                            }
+                        }
+                        for(let i = 0; i < trailingChunks.length; i++){
+                            controller.enqueue(trailingChunks[i]);
+                        }
+                        controller.close();
+                    }
+                });
+            default:
+                throw Object.defineProperty(new _invarianterror.InvariantError(`ServerPrerenderStreamResult cannot be consumed as a stream because it is not yet complete. status: ${this.status}`), "__NEXT_ERROR_CODE", {
+                    value: "E612",
+                    enumerable: false,
+                    configurable: true
+                });
+        }
+    }
+}
+class PhasedStream extends ReadableStream {
+    constructor(chunksByPhase){
+        if (chunksByPhase.length === 0) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('PhasedStream expected at least one phase but none were found.'), "__NEXT_ERROR_CODE", {
+                value: "E574",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let destination;
+        super({
+            start (controller) {
+                destination = controller;
+            }
+        });
+        // the start function above is called synchronously during construction so we will always have a destination
+        // We wait to assign it until after the super call because we cannot access `this` before calling super
+        this.destination = destination;
+        this.nextPhase = 0;
+        this.chunksByPhase = chunksByPhase;
+        this.releasePhase();
+    }
+    releasePhase() {
+        if (this.nextPhase < this.chunksByPhase.length) {
+            const chunks = this.chunksByPhase[this.nextPhase++];
+            for(let i = 0; i < chunks.length; i++){
+                this.destination.enqueue(chunks[i]);
+            }
+        } else {
+            throw Object.defineProperty(new _invarianterror.InvariantError('PhasedStream expected more phases to release but none were found.'), "__NEXT_ERROR_CODE", {
+                value: "E541",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    assertExhausted() {
+        if (this.nextPhase < this.chunksByPhase.length) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('PhasedStream expected no more phases to release but some were found.'), "__NEXT_ERROR_CODE", {
+                value: "E584",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+}
+function prerenderClientWithPhases(render, ...remainingPhases) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E538",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setImmediate(()=>{
+                try {
+                    pendingResult = render();
+                    pendingResult.catch((err)=>reject(err));
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            function runFinalTask() {
+                try {
+                    this();
+                    resolve(pendingResult);
+                } catch (err) {
+                    reject(err);
+                }
+            }
+            function runNextTask() {
+                try {
+                    this();
+                } catch (err) {
+                    reject(err);
+                }
+            }
+            let i = 0;
+            for(; i < remainingPhases.length - 1; i++){
+                const phase = remainingPhases[i];
+                setImmediate(runNextTask.bind(phase));
+            }
+            if (remainingPhases[i]) {
+                const finalPhase = remainingPhases[i];
+                setImmediate(runFinalTask.bind(finalPhase));
+            }
+        });
+    }
+}
+class ReactServerResult {
+    constructor(stream){
+        this._stream = stream;
+    }
+    tee() {
+        if (this._stream === null) {
+            throw Object.defineProperty(new Error('Cannot tee a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
+                value: "E106",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const tee = this._stream.tee();
+        this._stream = tee[0];
+        return tee[1];
+    }
+    consume() {
+        if (this._stream === null) {
+            throw Object.defineProperty(new Error('Cannot consume a ReactServerResult that has already been consumed'), "__NEXT_ERROR_CODE", {
+                value: "E470",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const stream = this._stream;
+        this._stream = null;
+        return stream;
+    }
+}
+async function createReactServerPrerenderResult(underlying) {
+    const chunks = [];
+    const { prelude } = await underlying;
+    const reader = prelude.getReader();
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            return new ReactServerPrerenderResult(chunks);
+        } else {
+            chunks.push(value);
+        }
+    }
+}
+async function createReactServerPrerenderResultFromRender(underlying) {
+    const chunks = [];
+    const reader = underlying.getReader();
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        } else {
+            chunks.push(value);
+        }
+    }
+    return new ReactServerPrerenderResult(chunks);
+}
+class ReactServerPrerenderResult {
+    assertChunks(expression) {
+        if (this._chunks === null) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot \`${expression}\` on a ReactServerPrerenderResult that has already been consumed.`), "__NEXT_ERROR_CODE", {
+                value: "E593",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return this._chunks;
+    }
+    consumeChunks(expression) {
+        const chunks = this.assertChunks(expression);
+        this.consume();
+        return chunks;
+    }
+    consume() {
+        this._chunks = null;
+    }
+    constructor(chunks){
+        this._chunks = chunks;
+    }
+    asUnclosingStream() {
+        const chunks = this.assertChunks('asUnclosingStream()');
+        return createUnclosingStream(chunks);
+    }
+    consumeAsUnclosingStream() {
+        const chunks = this.consumeChunks('consumeAsUnclosingStream()');
+        return createUnclosingStream(chunks);
+    }
+    asStream() {
+        const chunks = this.assertChunks('asStream()');
+        return createClosingStream(chunks);
+    }
+    consumeAsStream() {
+        const chunks = this.consumeChunks('consumeAsStream()');
+        return createClosingStream(chunks);
+    }
+}
+function createUnclosingStream(chunks) {
+    let i = 0;
+    return new ReadableStream({
+        async pull (controller) {
+            if (i < chunks.length) {
+                controller.enqueue(chunks[i++]);
+            }
+        // we intentionally keep the stream open. The consumer will clear
+        // out chunks once finished and the remaining memory will be GC'd
+        // when this object goes out of scope
+        }
+    });
+}
+function createClosingStream(chunks) {
+    let i = 0;
+    return new ReadableStream({
+        async pull (controller) {
+            if (i < chunks.length) {
+                controller.enqueue(chunks[i++]);
+            } else {
+                controller.close();
+            }
+        }
+    });
+}
+
+//# sourceMappingURL=app-render-prerender-utils.js.map

frontend/webapp/node_modules/next/dist/server/app-render/app-render-render-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This is a utility function to make scheduling sequential tasks that run back to back easier.
+ * We schedule on the same queue (setImmediate) at the same time to ensure no other events can sneak in between.
+ */
+export declare function scheduleInSequentialTasks<R>(render: () => R | Promise<R>, followup: () => void): Promise<R>;

frontend/webapp/node_modules/next/dist/server/app-render/app-render-render-utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "scheduleInSequentialTasks", {
+    enumerable: true,
+    get: function() {
+        return scheduleInSequentialTasks;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+function scheduleInSequentialTasks(render, followup) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('`scheduleInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
+            value: "E591",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        return new Promise((resolve, reject)=>{
+            let pendingResult;
+            setImmediate(()=>{
+                try {
+                    pendingResult = render();
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            setImmediate(()=>{
+                followup();
+                resolve(pendingResult);
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=app-render-render-utils.js.map

frontend/webapp/node_modules/next/dist/server/app-render/app-render-render-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/app-render-render-utils.ts"],"sourcesContent":["import { InvariantError } from '../../shared/lib/invariant-error'\n\n/**\n * This is a utility function to make scheduling sequential tasks that run back to back easier.\n * We schedule on the same queue (setImmediate) at the same time to ensure no other events can sneak in between.\n */\nexport function scheduleInSequentialTasks<R>(\n  render: () => R | Promise<R>,\n  followup: () => void\n): Promise<R> {\n  if (process.env.NEXT_RUNTIME === 'edge') {\n    throw new InvariantError(\n      '`scheduleInSequentialTasks` should not be called in edge runtime.'\n    )\n  } else {\n    return new Promise((resolve, reject) => {\n      let pendingResult: R | Promise<R>\n      setImmediate(() => {\n        try {\n          pendingResult = render()\n        } catch (err) {\n          reject(err)\n        }\n      })\n      setImmediate(() => {\n        followup()\n        resolve(pendingResult)\n      })\n    })\n  }\n}\n"],"names":["scheduleInSequentialTasks","render","followup","process","env","NEXT_RUNTIME","InvariantError","Promise","resolve","reject","pendingResult","setImmediate","err"],"mappings":";;;;+BAMgBA;;;eAAAA;;;gCANe;AAMxB,SAASA,0BACdC,MAA4B,EAC5BC,QAAoB;IAEpB,IAAIC,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;QACvC,MAAM,qBAEL,CAFK,IAAIC,8BAAc,CACtB,sEADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF,OAAO;QACL,OAAO,IAAIC,QAAQ,CAACC,SAASC;YAC3B,IAAIC;YACJC,aAAa;gBACX,IAAI;oBACFD,gBAAgBT;gBAClB,EAAE,OAAOW,KAAK;oBACZH,OAAOG;gBACT;YACF;YACAD,aAAa;gBACXT;gBACAM,QAAQE;YACV;QACF;IACF;AACF"}

frontend/webapp/node_modules/next/dist/server/app-render/app-render.d.ts

@@ -0,0 +1,84 @@
+import type { ActionResult, DynamicParamTypesShort, FlightRouterState, RenderOpts, Segment, CacheNodeSeedData, PreloadCallbacks } from './types';
+import { type WorkStore } from '../app-render/work-async-storage.external';
+import type { RequestStore } from '../app-render/work-unit-async-storage.external';
+import type { NextParsedUrlQuery } from '../request-meta';
+import type { AppPageModule } from '../route-modules/app-page/module';
+import type { ClientReferenceManifest } from '../../build/webpack/plugins/flight-manifest-plugin';
+import type { DeepReadonly } from '../../shared/lib/deep-readonly';
+import type { BaseNextRequest, BaseNextResponse } from '../base-http';
+import RenderResult, { type AppPageRenderResultMetadata } from '../render-result';
+import { type ImplicitTags } from '../lib/implicit-tags';
+import { parseRelativeUrl } from '../../shared/lib/router/utils/parse-relative-url';
+import type { ServerComponentsHmrCache } from '../response-cache';
+import type { FallbackRouteParams } from '../request/fallback-params';
+import './clean-async-snapshot.external';
+export type GetDynamicParamFromSegment = (segment: string) => {
+    param: string;
+    value: string | string[] | null;
+    treeSegment: Segment;
+    type: DynamicParamTypesShort;
+} | null;
+export type GenerateFlight = typeof generateDynamicFlightRenderResult;
+export type AppSharedContext = {
+    buildId: string;
+};
+export type AppRenderContext = {
+    sharedContext: AppSharedContext;
+    workStore: WorkStore;
+    url: ReturnType<typeof parseRelativeUrl>;
+    componentMod: AppPageModule;
+    renderOpts: RenderOpts;
+    parsedRequestHeaders: ParsedRequestHeaders;
+    getDynamicParamFromSegment: GetDynamicParamFromSegment;
+    query: NextParsedUrlQuery;
+    isPrefetch: boolean;
+    isPossibleServerAction: boolean;
+    requestTimestamp: number;
+    appUsingSizeAdjustment: boolean;
+    flightRouterState?: FlightRouterState;
+    requestId: string;
+    pagePath: string;
+    clientReferenceManifest: DeepReadonly<ClientReferenceManifest>;
+    assetPrefix: string;
+    isNotFoundPath: boolean;
+    nonce: string | undefined;
+    res: BaseNextResponse;
+    /**
+     * For now, the implicit tags are common for the whole route. If we ever start
+     * rendering/revalidating segments independently, they need to move to the
+     * work unit store.
+     */
+    implicitTags: ImplicitTags;
+};
+interface ParsedRequestHeaders {
+    /**
+     * Router state provided from the client-side router. Used to handle rendering
+     * from the common layout down. This value will be undefined if the request is
+     * not a client-side navigation request, or if the request is a prefetch
+     * request.
+     */
+    readonly flightRouterState: FlightRouterState | undefined;
+    readonly isPrefetchRequest: boolean;
+    readonly isRouteTreePrefetchRequest: boolean;
+    readonly isDevWarmupRequest: boolean;
+    readonly isHmrRefresh: boolean;
+    readonly isRSCRequest: boolean;
+    readonly nonce: string | undefined;
+    readonly previouslyRevalidatedTags: string[];
+}
+/**
+ * Produces a RenderResult containing the Flight data for the given request. See
+ * `generateDynamicRSCPayload` for information on the contents of the render result.
+ */
+declare function generateDynamicFlightRenderResult(req: BaseNextRequest, ctx: AppRenderContext, requestStore: RequestStore, options?: {
+    actionResult: ActionResult;
+    skipFlight: boolean;
+    componentTree?: CacheNodeSeedData;
+    preloadCallbacks?: PreloadCallbacks;
+    temporaryReferences?: WeakMap<any, string>;
+}): Promise<RenderResult>;
+export type BinaryStreamOf<T> = ReadableStream<Uint8Array>;
+export type AppPageRender = (req: BaseNextRequest, res: BaseNextResponse, pagePath: string, query: NextParsedUrlQuery, fallbackRouteParams: FallbackRouteParams | null, renderOpts: RenderOpts, serverComponentsHmrCache: ServerComponentsHmrCache | undefined, isDevWarmup: boolean, sharedContext: AppSharedContext) => Promise<RenderResult<AppPageRenderResultMetadata>>;
+export declare const renderToHTMLOrFlight: AppPageRender;
+export declare function warmFlightResponse(flightStream: ReadableStream<Uint8Array>, clientReferenceManifest: DeepReadonly<ClientReferenceManifest>): Promise<unknown>;
+export {};

frontend/webapp/node_modules/next/dist/server/app-render/async-local-storage.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncLocalStorage } from 'async_hooks';
+export declare function createAsyncLocalStorage<Store extends {}>(): AsyncLocalStorage<Store>;
+export declare function bindSnapshot<T>(fn: T): T;
+export declare function createSnapshot(): <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;

frontend/webapp/node_modules/next/dist/server/app-render/async-local-storage.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bindSnapshot: null,
+    createAsyncLocalStorage: null,
+    createSnapshot: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bindSnapshot: function() {
+        return bindSnapshot;
+    },
+    createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+    },
+    createSnapshot: function() {
+        return createSnapshot;
+    }
+});
+const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error('Invariant: AsyncLocalStorage accessed in runtime where it is not available'), "__NEXT_ERROR_CODE", {
+    value: "E504",
+    enumerable: false,
+    configurable: true
+});
+class FakeAsyncLocalStorage {
+    disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    getStore() {
+        // This fake implementation of AsyncLocalStorage always returns `undefined`.
+        return undefined;
+    }
+    run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    static bind(fn) {
+        return fn;
+    }
+}
+const maybeGlobalAsyncLocalStorage = typeof globalThis !== 'undefined' && globalThis.AsyncLocalStorage;
+function createAsyncLocalStorage() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+    }
+    return new FakeAsyncLocalStorage();
+}
+function bindSnapshot(fn) {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+    }
+    return FakeAsyncLocalStorage.bind(fn);
+}
+function createSnapshot() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+    }
+    return function(fn, ...args) {
+        return fn(...args);
+    };
+}
+
+//# sourceMappingURL=async-local-storage.js.map

frontend/webapp/node_modules/next/dist/server/app-render/async-local-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/async-local-storage.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'async_hooks'\n\nconst sharedAsyncLocalStorageNotAvailableError = new Error(\n  'Invariant: AsyncLocalStorage accessed in runtime where it is not available'\n)\n\nclass FakeAsyncLocalStorage<Store extends {}>\n  implements AsyncLocalStorage<Store>\n{\n  disable(): void {\n    throw sharedAsyncLocalStorageNotAvailableError\n  }\n\n  getStore(): Store | undefined {\n    // This fake implementation of AsyncLocalStorage always returns `undefined`.\n    return undefined\n  }\n\n  run<R>(): R {\n    throw sharedAsyncLocalStorageNotAvailableError\n  }\n\n  exit<R>(): R {\n    throw sharedAsyncLocalStorageNotAvailableError\n  }\n\n  enterWith(): void {\n    throw sharedAsyncLocalStorageNotAvailableError\n  }\n\n  static bind<T>(fn: T): T {\n    return fn\n  }\n}\n\nconst maybeGlobalAsyncLocalStorage =\n  typeof globalThis !== 'undefined' && (globalThis as any).AsyncLocalStorage\n\nexport function createAsyncLocalStorage<\n  Store extends {},\n>(): AsyncLocalStorage<Store> {\n  if (maybeGlobalAsyncLocalStorage) {\n    return new maybeGlobalAsyncLocalStorage()\n  }\n  return new FakeAsyncLocalStorage()\n}\n\nexport function bindSnapshot<T>(fn: T): T {\n  if (maybeGlobalAsyncLocalStorage) {\n    return maybeGlobalAsyncLocalStorage.bind(fn)\n  }\n  return FakeAsyncLocalStorage.bind(fn)\n}\n\nexport function createSnapshot(): <R, TArgs extends any[]>(\n  fn: (...args: TArgs) => R,\n  ...args: TArgs\n) => R {\n  if (maybeGlobalAsyncLocalStorage) {\n    return maybeGlobalAsyncLocalStorage.snapshot()\n  }\n  return function (fn: any, ...args: any[]) {\n    return fn(...args)\n  }\n}\n"],"names":["bindSnapshot","createAsyncLocalStorage","createSnapshot","sharedAsyncLocalStorageNotAvailableError","Error","FakeAsyncLocalStorage","disable","getStore","undefined","run","exit","enterWith","bind","fn","maybeGlobalAsyncLocalStorage","globalThis","AsyncLocalStorage","snapshot","args"],"mappings":";;;;;;;;;;;;;;;;IA+CgBA,YAAY;eAAZA;;IATAC,uBAAuB;eAAvBA;;IAgBAC,cAAc;eAAdA;;;AApDhB,MAAMC,2CAA2C,qBAEhD,CAFgD,IAAIC,MACnD,+EAD+C,qBAAA;WAAA;gBAAA;kBAAA;AAEjD;AAEA,MAAMC;IAGJC,UAAgB;QACd,MAAMH;IACR;IAEAI,WAA8B;QAC5B,4EAA4E;QAC5E,OAAOC;IACT;IAEAC,MAAY;QACV,MAAMN;IACR;IAEAO,OAAa;QACX,MAAMP;IACR;IAEAQ,YAAkB;QAChB,MAAMR;IACR;IAEA,OAAOS,KAAQC,EAAK,EAAK;QACvB,OAAOA;IACT;AACF;AAEA,MAAMC,+BACJ,OAAOC,eAAe,eAAe,AAACA,WAAmBC,iBAAiB;AAErE,SAASf;IAGd,IAAIa,8BAA8B;QAChC,OAAO,IAAIA;IACb;IACA,OAAO,IAAIT;AACb;AAEO,SAASL,aAAgBa,EAAK;IACnC,IAAIC,8BAA8B;QAChC,OAAOA,6BAA6BF,IAAI,CAACC;IAC3C;IACA,OAAOR,sBAAsBO,IAAI,CAACC;AACpC;AAEO,SAASX;IAId,IAAIY,8BAA8B;QAChC,OAAOA,6BAA6BG,QAAQ;IAC9C;IACA,OAAO,SAAUJ,EAAO,EAAE,GAAGK,IAAW;QACtC,OAAOL,MAAMK;IACf;AACF"}

frontend/webapp/node_modules/next/dist/server/app-render/cache-signal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This class is used to detect when all cache reads for a given render are settled.
+ * We do this to allow for cache warming the prerender without having to continue rendering
+ * the remainder of the page. This feature is really only useful when the dynamicIO flag is on
+ * and should only be used in codepaths gated with this feature.
+ */
+export declare class CacheSignal {
+    private count;
+    private earlyListeners;
+    private listeners;
+    private tickPending;
+    private taskPending;
+    constructor();
+    private noMorePendingCaches;
+    /**
+     * This promise waits until there are no more in progress cache reads but no later.
+     * This allows for adding more cache reads after to delay cacheReady.
+     */
+    inputReady(): Promise<void>;
+    /**
+     * If there are inflight cache reads this Promise can resolve in a microtask however
+     * if there are no inflight cache reads then we wait at least one task to allow initial
+     * cache reads to be initiated.
+     */
+    cacheReady(): Promise<void>;
+    beginRead(): void;
+    endRead(): void;
+}

frontend/webapp/node_modules/next/dist/server/app-render/cache-signal.js

@@ -0,0 +1,90 @@
+/**
+ * This class is used to detect when all cache reads for a given render are settled.
+ * We do this to allow for cache warming the prerender without having to continue rendering
+ * the remainder of the page. This feature is really only useful when the dynamicIO flag is on
+ * and should only be used in codepaths gated with this feature.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CacheSignal", {
+    enumerable: true,
+    get: function() {
+        return CacheSignal;
+    }
+});
+class CacheSignal {
+    constructor(){
+        this.count = 0;
+        this.earlyListeners = [];
+        this.listeners = [];
+        this.tickPending = false;
+        this.taskPending = false;
+    }
+    noMorePendingCaches() {
+        if (!this.tickPending) {
+            this.tickPending = true;
+            process.nextTick(()=>{
+                this.tickPending = false;
+                if (this.count === 0) {
+                    for(let i = 0; i < this.earlyListeners.length; i++){
+                        this.earlyListeners[i]();
+                    }
+                    this.earlyListeners.length = 0;
+                }
+            });
+        }
+        if (!this.taskPending) {
+            this.taskPending = true;
+            setTimeout(()=>{
+                this.taskPending = false;
+                if (this.count === 0) {
+                    for(let i = 0; i < this.listeners.length; i++){
+                        this.listeners[i]();
+                    }
+                    this.listeners.length = 0;
+                }
+            }, 0);
+        }
+    }
+    /**
+   * This promise waits until there are no more in progress cache reads but no later.
+   * This allows for adding more cache reads after to delay cacheReady.
+   */ inputReady() {
+        return new Promise((resolve)=>{
+            this.earlyListeners.push(resolve);
+            if (this.count === 0) {
+                this.noMorePendingCaches();
+            }
+        });
+    }
+    /**
+   * If there are inflight cache reads this Promise can resolve in a microtask however
+   * if there are no inflight cache reads then we wait at least one task to allow initial
+   * cache reads to be initiated.
+   */ cacheReady() {
+        return new Promise((resolve)=>{
+            this.listeners.push(resolve);
+            if (this.count === 0) {
+                this.noMorePendingCaches();
+            }
+        });
+    }
+    beginRead() {
+        this.count++;
+    }
+    endRead() {
+        // If this is the last read we need to wait a task before we can claim the cache is settled.
+        // The cache read will likely ping a Server Component which can read from the cache again and this
+        // will play out in a microtask so we need to only resolve pending listeners if we're still at 0
+        // after at least one task.
+        // We only want one task scheduled at a time so when we hit count 1 we don't decrement the counter immediately.
+        // If intervening reads happen before the scheduled task runs they will never observe count 1 preventing reentrency
+        this.count--;
+        if (this.count === 0) {
+            this.noMorePendingCaches();
+        }
+    }
+}
+
+//# sourceMappingURL=cache-signal.js.map

frontend/webapp/node_modules/next/dist/server/app-render/cache-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/cache-signal.ts"],"sourcesContent":["/**\n * This class is used to detect when all cache reads for a given render are settled.\n * We do this to allow for cache warming the prerender without having to continue rendering\n * the remainder of the page. This feature is really only useful when the dynamicIO flag is on\n * and should only be used in codepaths gated with this feature.\n */\n\nexport class CacheSignal {\n  private count: number\n  private earlyListeners: Array<() => void>\n  private listeners: Array<() => void>\n  private tickPending: boolean\n  private taskPending: boolean\n\n  constructor() {\n    this.count = 0\n    this.earlyListeners = []\n    this.listeners = []\n    this.tickPending = false\n    this.taskPending = false\n  }\n\n  private noMorePendingCaches() {\n    if (!this.tickPending) {\n      this.tickPending = true\n      process.nextTick(() => {\n        this.tickPending = false\n        if (this.count === 0) {\n          for (let i = 0; i < this.earlyListeners.length; i++) {\n            this.earlyListeners[i]()\n          }\n          this.earlyListeners.length = 0\n        }\n      })\n    }\n    if (!this.taskPending) {\n      this.taskPending = true\n      setTimeout(() => {\n        this.taskPending = false\n        if (this.count === 0) {\n          for (let i = 0; i < this.listeners.length; i++) {\n            this.listeners[i]()\n          }\n          this.listeners.length = 0\n        }\n      }, 0)\n    }\n  }\n\n  /**\n   * This promise waits until there are no more in progress cache reads but no later.\n   * This allows for adding more cache reads after to delay cacheReady.\n   */\n  inputReady() {\n    return new Promise<void>((resolve) => {\n      this.earlyListeners.push(resolve)\n      if (this.count === 0) {\n        this.noMorePendingCaches()\n      }\n    })\n  }\n\n  /**\n   * If there are inflight cache reads this Promise can resolve in a microtask however\n   * if there are no inflight cache reads then we wait at least one task to allow initial\n   * cache reads to be initiated.\n   */\n  cacheReady() {\n    return new Promise<void>((resolve) => {\n      this.listeners.push(resolve)\n      if (this.count === 0) {\n        this.noMorePendingCaches()\n      }\n    })\n  }\n\n  beginRead() {\n    this.count++\n  }\n\n  endRead() {\n    // If this is the last read we need to wait a task before we can claim the cache is settled.\n    // The cache read will likely ping a Server Component which can read from the cache again and this\n    // will play out in a microtask so we need to only resolve pending listeners if we're still at 0\n    // after at least one task.\n    // We only want one task scheduled at a time so when we hit count 1 we don't decrement the counter immediately.\n    // If intervening reads happen before the scheduled task runs they will never observe count 1 preventing reentrency\n    this.count--\n    if (this.count === 0) {\n      this.noMorePendingCaches()\n    }\n  }\n}\n"],"names":["CacheSignal","constructor","count","earlyListeners","listeners","tickPending","taskPending","noMorePendingCaches","process","nextTick","i","length","setTimeout","inputReady","Promise","resolve","push","cacheReady","beginRead","endRead"],"mappings":"AAAA;;;;;CAKC;;;;+BAEYA;;;eAAAA;;;AAAN,MAAMA;IAOXC,aAAc;QACZ,IAAI,CAACC,KAAK,GAAG;QACb,IAAI,CAACC,cAAc,GAAG,EAAE;QACxB,IAAI,CAACC,SAAS,GAAG,EAAE;QACnB,IAAI,CAACC,WAAW,GAAG;QACnB,IAAI,CAACC,WAAW,GAAG;IACrB;IAEQC,sBAAsB;QAC5B,IAAI,CAAC,IAAI,CAACF,WAAW,EAAE;YACrB,IAAI,CAACA,WAAW,GAAG;YACnBG,QAAQC,QAAQ,CAAC;gBACf,IAAI,CAACJ,WAAW,GAAG;gBACnB,IAAI,IAAI,CAACH,KAAK,KAAK,GAAG;oBACpB,IAAK,IAAIQ,IAAI,GAAGA,IAAI,IAAI,CAACP,cAAc,CAACQ,MAAM,EAAED,IAAK;wBACnD,IAAI,CAACP,cAAc,CAACO,EAAE;oBACxB;oBACA,IAAI,CAACP,cAAc,CAACQ,MAAM,GAAG;gBAC/B;YACF;QACF;QACA,IAAI,CAAC,IAAI,CAACL,WAAW,EAAE;YACrB,IAAI,CAACA,WAAW,GAAG;YACnBM,WAAW;gBACT,IAAI,CAACN,WAAW,GAAG;gBACnB,IAAI,IAAI,CAACJ,KAAK,KAAK,GAAG;oBACpB,IAAK,IAAIQ,IAAI,GAAGA,IAAI,IAAI,CAACN,SAAS,CAACO,MAAM,EAAED,IAAK;wBAC9C,IAAI,CAACN,SAAS,CAACM,EAAE;oBACnB;oBACA,IAAI,CAACN,SAAS,CAACO,MAAM,GAAG;gBAC1B;YACF,GAAG;QACL;IACF;IAEA;;;GAGC,GACDE,aAAa;QACX,OAAO,IAAIC,QAAc,CAACC;YACxB,IAAI,CAACZ,cAAc,CAACa,IAAI,CAACD;YACzB,IAAI,IAAI,CAACb,KAAK,KAAK,GAAG;gBACpB,IAAI,CAACK,mBAAmB;YAC1B;QACF;IACF;IAEA;;;;GAIC,GACDU,aAAa;QACX,OAAO,IAAIH,QAAc,CAACC;YACxB,IAAI,CAACX,SAAS,CAACY,IAAI,CAACD;YACpB,IAAI,IAAI,CAACb,KAAK,KAAK,GAAG;gBACpB,IAAI,CAACK,mBAAmB;YAC1B;QACF;IACF;IAEAW,YAAY;QACV,IAAI,CAAChB,KAAK;IACZ;IAEAiB,UAAU;QACR,4FAA4F;QAC5F,kGAAkG;QAClG,gGAAgG;QAChG,2BAA2B;QAC3B,+GAA+G;QAC/G,mHAAmH;QACnH,IAAI,CAACjB,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACK,mBAAmB;QAC1B;IACF;AACF"}

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot-instance.d.ts

@@ -0,0 +1 @@
+export declare const runInCleanSnapshot: <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot-instance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runInCleanSnapshot", {
+    enumerable: true,
+    get: function() {
+        return runInCleanSnapshot;
+    }
+});
+const _asynclocalstorage = require("../app-render/async-local-storage");
+const runInCleanSnapshot = (0, _asynclocalstorage.createSnapshot)();
+
+//# sourceMappingURL=clean-async-snapshot-instance.js.map

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/clean-async-snapshot-instance.ts"],"sourcesContent":["import { createSnapshot } from '../app-render/async-local-storage'\n\nexport const runInCleanSnapshot: <R, TArgs extends any[]>(\n  fn: (...args: TArgs) => R,\n  ...args: TArgs\n) => R = createSnapshot()\n"],"names":["runInCleanSnapshot","createSnapshot"],"mappings":";;;;+BAEaA;;;eAAAA;;;mCAFkB;AAExB,MAAMA,qBAGJC,IAAAA,iCAAc"}

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot.external.d.ts

@@ -0,0 +1,2 @@
+import { runInCleanSnapshot } from './clean-async-snapshot-instance';
+export { runInCleanSnapshot };

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot.external.js

@@ -0,0 +1,14 @@
+// Share the instance module in the next-shared layer
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runInCleanSnapshot", {
+    enumerable: true,
+    get: function() {
+        return _cleanasyncsnapshotinstance.runInCleanSnapshot;
+    }
+});
+const _cleanasyncsnapshotinstance = require("./clean-async-snapshot-instance");
+
+//# sourceMappingURL=clean-async-snapshot.external.js.map

frontend/webapp/node_modules/next/dist/server/app-render/clean-async-snapshot.external.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/clean-async-snapshot.external.ts"],"sourcesContent":["// Share the instance module in the next-shared layer\nimport { runInCleanSnapshot } from './clean-async-snapshot-instance' with { 'turbopack-transition': 'next-shared' }\n\nexport { runInCleanSnapshot }\n"],"names":["runInCleanSnapshot"],"mappings":"AAAA,qDAAqD;;;;;+BAG5CA;;;eAAAA,8CAAkB;;;4CAFQ"}

frontend/webapp/node_modules/next/dist/server/app-render/collect-segment-data.d.ts

@@ -0,0 +1,25 @@
+import type { Segment as FlightRouterStateSegment } from './types';
+import type { ManifestNode } from '../../build/webpack/plugins/flight-manifest-plugin';
+import type { HeadData, LoadingModuleData } from '../../shared/lib/app-router-context.shared-runtime';
+import type { FallbackRouteParams } from '../request/fallback-params';
+export type RootTreePrefetch = {
+    buildId: string;
+    tree: TreePrefetch;
+    head: HeadData;
+    isHeadPartial: boolean;
+    staleTime: number;
+};
+export type TreePrefetch = {
+    segment: FlightRouterStateSegment;
+    slots: null | {
+        [parallelRouteKey: string]: TreePrefetch;
+    };
+    isRootLayout: boolean;
+};
+export type SegmentPrefetch = {
+    buildId: string;
+    rsc: React.ReactNode | null;
+    loading: LoadingModuleData | Promise<LoadingModuleData>;
+    isPartial: boolean;
+};
+export declare function collectSegmentData(shouldAssumePartialData: boolean, fullPageDataBuffer: Buffer, staleTime: number, clientModules: ManifestNode, serverConsumerManifest: any, fallbackRouteParams: FallbackRouteParams | null): Promise<Map<string, Buffer>>;

frontend/webapp/node_modules/next/dist/server/app-render/collect-segment-data.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "collectSegmentData", {
+    enumerable: true,
+    get: function() {
+        return collectSegmentData;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _clientedge = require("react-server-dom-webpack/client.edge");
+const _staticedge = require("react-server-dom-webpack/static.edge");
+const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _scheduler = require("../../lib/scheduler");
+const _segmentvalueencoding = require("../../shared/lib/segment-cache/segment-value-encoding");
+const _createerrorhandler = require("./create-error-handler");
+function onSegmentPrerenderError(error) {
+    const digest = (0, _createerrorhandler.getDigestForWellKnownError)(error);
+    if (digest) {
+        return digest;
+    }
+// We don't need to log the errors because we would have already done that
+// when generating the original Flight stream for the whole page.
+}
+async function collectSegmentData(shouldAssumePartialData, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, fallbackRouteParams) {
+    // Traverse the router tree and generate a prefetch response for each segment.
+    // A mutable map to collect the results as we traverse the route tree.
+    const resultMap = new Map();
+    // Before we start, warm up the module cache by decoding the page data once.
+    // Then we can assume that any remaining async tasks that occur the next time
+    // are due to hanging promises caused by dynamic data access. Note we only
+    // have to do this once per page, not per individual segment.
+    //
+    try {
+        await (0, _clientedge.createFromReadableStream)((0, _nodewebstreamshelper.streamFromBuffer)(fullPageDataBuffer), {
+            serverConsumerManifest
+        });
+        await (0, _scheduler.waitAtLeastOneReactRenderTask)();
+    } catch  {}
+    // Create an abort controller that we'll use to stop the stream.
+    const abortController = new AbortController();
+    const onCompletedProcessingRouteTree = async ()=>{
+        // Since all we're doing is decoding and re-encoding a cached prerender, if
+        // serializing the stream takes longer than a microtask, it must because of
+        // hanging promises caused by dynamic data.
+        await (0, _scheduler.waitAtLeastOneReactRenderTask)();
+        abortController.abort();
+    };
+    // Generate a stream for the route tree prefetch. While we're walking the
+    // tree, we'll also spawn additional tasks to generate the segment prefetches.
+    // The promises for these tasks are pushed to a mutable array that we will
+    // await once the route tree is fully rendered.
+    const segmentTasks = [];
+    const { prelude: treeStream } = await (0, _staticedge.unstable_prerender)(// RootTreePrefetch is not a valid return type for a React component, but
+    // we need to use a component so that when we decode the original stream
+    // inside of it, the side effects are transferred to the new stream.
+    // @ts-expect-error
+    /*#__PURE__*/ (0, _jsxruntime.jsx)(PrefetchTreeData, {
+        shouldAssumePartialData: shouldAssumePartialData,
+        fullPageDataBuffer: fullPageDataBuffer,
+        fallbackRouteParams: fallbackRouteParams,
+        serverConsumerManifest: serverConsumerManifest,
+        clientModules: clientModules,
+        staleTime: staleTime,
+        segmentTasks: segmentTasks,
+        onCompletedProcessingRouteTree: onCompletedProcessingRouteTree
+    }), clientModules, {
+        signal: abortController.signal,
+        onError: onSegmentPrerenderError
+    });
+    // Write the route tree to a special `/_tree` segment.
+    const treeBuffer = await (0, _nodewebstreamshelper.streamToBuffer)(treeStream);
+    resultMap.set('/_tree', treeBuffer);
+    // Now that we've finished rendering the route tree, all the segment tasks
+    // should have been spawned. Await them in parallel and write the segment
+    // prefetches to the result map.
+    for (const [segmentPath, buffer] of (await Promise.all(segmentTasks))){
+        resultMap.set(segmentPath, buffer);
+    }
+    return resultMap;
+}
+async function PrefetchTreeData({ shouldAssumePartialData, fullPageDataBuffer, fallbackRouteParams, serverConsumerManifest, clientModules, staleTime, segmentTasks, onCompletedProcessingRouteTree }) {
+    // We're currently rendering a Flight response for the route tree prefetch.
+    // Inside this component, decode the Flight stream for the whole page. This is
+    // a hack to transfer the side effects from the original Flight stream (e.g.
+    // Float preloads) onto the Flight stream for the tree prefetch.
+    // TODO: React needs a better way to do this. Needed for Server Actions, too.
+    const initialRSCPayload = await (0, _clientedge.createFromReadableStream)(createUnclosingPrefetchStream((0, _nodewebstreamshelper.streamFromBuffer)(fullPageDataBuffer)), {
+        serverConsumerManifest
+    });
+    const buildId = initialRSCPayload.b;
+    // FlightDataPath is an unsound type, hence the additional checks.
+    const flightDataPaths = initialRSCPayload.f;
+    if (flightDataPaths.length !== 1 && flightDataPaths[0].length !== 3) {
+        console.error('Internal Next.js error: InitialRSCPayload does not match the expected ' + 'shape for a prerendered page during segment prefetch generation.');
+        return null;
+    }
+    const flightRouterState = flightDataPaths[0][0];
+    const seedData = flightDataPaths[0][1];
+    const head = flightDataPaths[0][2];
+    // Compute the route metadata tree by traversing the FlightRouterState. As we
+    // walk the tree, we will also spawn a task to produce a prefetch response for
+    // each segment.
+    const tree = collectSegmentDataImpl(shouldAssumePartialData, flightRouterState, buildId, seedData, fallbackRouteParams, fullPageDataBuffer, clientModules, serverConsumerManifest, _segmentvalueencoding.ROOT_SEGMENT_KEY, segmentTasks);
+    const isHeadPartial = shouldAssumePartialData || await isPartialRSCData(head, clientModules);
+    // Notify the abort controller that we're done processing the route tree.
+    // Anything async that happens after this point must be due to hanging
+    // promises in the original stream.
+    onCompletedProcessingRouteTree();
+    // Render the route tree to a special `/_tree` segment.
+    const treePrefetch = {
+        buildId,
+        tree,
+        head,
+        isHeadPartial,
+        staleTime
+    };
+    return treePrefetch;
+}
+function collectSegmentDataImpl(shouldAssumePartialData, route, buildId, seedData, fallbackRouteParams, fullPageDataBuffer, clientModules, serverConsumerManifest, key, segmentTasks) {
+    // Metadata about the segment. Sent as part of the tree prefetch. Null if
+    // there are no children.
+    let slotMetadata = null;
+    const children = route[1];
+    const seedDataChildren = seedData !== null ? seedData[2] : null;
+    for(const parallelRouteKey in children){
+        const childRoute = children[parallelRouteKey];
+        const childSegment = childRoute[0];
+        const childSeedData = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
+        const childKey = (0, _segmentvalueencoding.encodeChildSegmentKey)(key, parallelRouteKey, Array.isArray(childSegment) && fallbackRouteParams !== null ? encodeSegmentWithPossibleFallbackParam(childSegment, fallbackRouteParams) : (0, _segmentvalueencoding.encodeSegment)(childSegment));
+        const childTree = collectSegmentDataImpl(shouldAssumePartialData, childRoute, buildId, childSeedData, fallbackRouteParams, fullPageDataBuffer, clientModules, serverConsumerManifest, childKey, segmentTasks);
+        if (slotMetadata === null) {
+            slotMetadata = {};
+        }
+        slotMetadata[parallelRouteKey] = childTree;
+    }
+    if (seedData !== null) {
+        // Spawn a task to write the segment data to a new Flight stream.
+        segmentTasks.push(// Since we're already in the middle of a render, wait until after the
+        // current task to escape the current rendering context.
+        (0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>renderSegmentPrefetch(shouldAssumePartialData, buildId, seedData, key, clientModules)));
+    } else {
+    // This segment does not have any seed data. Skip generating a prefetch
+    // response for it. We'll still include it in the route tree, though.
+    // TODO: We should encode in the route tree whether a segment is missing
+    // so we don't attempt to fetch it for no reason. As of now this shouldn't
+    // ever happen in practice, though.
+    }
+    // Metadata about the segment. Sent to the client as part of the
+    // tree prefetch.
+    return {
+        segment: route[0],
+        slots: slotMetadata,
+        isRootLayout: route[4] === true
+    };
+}
+function encodeSegmentWithPossibleFallbackParam(segment, fallbackRouteParams) {
+    const name = segment[0];
+    if (!fallbackRouteParams.has(name)) {
+        // Normal case. No matching fallback parameter.
+        return (0, _segmentvalueencoding.encodeSegment)(segment);
+    }
+    // This segment includes a fallback parameter. During prerendering, a random
+    // placeholder value was used; however, for segment prefetches, we need the
+    // segment path to be predictable so the server can create a rewrite for it.
+    // So, replace the placeholder segment value with a "template" string,
+    // e.g. `[name]`.
+    // TODO: This will become a bit cleaner once remove route parameters from the
+    // server response, and instead add them to the segment keys on the client.
+    // Instead of a string replacement, like we do here, route params will always
+    // be encoded in separate step from the rest of the segment, not just in the
+    // case of fallback params.
+    const encodedSegment = (0, _segmentvalueencoding.encodeSegment)(segment);
+    const lastIndex = encodedSegment.lastIndexOf('$');
+    const encodedFallbackSegment = // NOTE: This is guaranteed not to clash with the rest of the segment
+    // because non-simple characters (including [ and ]) trigger a base
+    // 64 encoding.
+    encodedSegment.substring(0, lastIndex + 1) + `[${name}]`;
+    return encodedFallbackSegment;
+}
+async function renderSegmentPrefetch(shouldAssumePartialData, buildId, seedData, key, clientModules) {
+    // Render the segment data to a stream.
+    // In the future, this is where we can include additional metadata, like the
+    // stale time and cache tags.
+    const rsc = seedData[1];
+    const loading = seedData[3];
+    const segmentPrefetch = {
+        buildId,
+        rsc,
+        loading,
+        isPartial: shouldAssumePartialData || await isPartialRSCData(rsc, clientModules)
+    };
+    // Since all we're doing is decoding and re-encoding a cached prerender, if
+    // it takes longer than a microtask, it must because of hanging promises
+    // caused by dynamic data. Abort the stream at the end of the current task.
+    const abortController = new AbortController();
+    (0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>abortController.abort());
+    const { prelude: segmentStream } = await (0, _staticedge.unstable_prerender)(segmentPrefetch, clientModules, {
+        signal: abortController.signal,
+        onError: onSegmentPrerenderError
+    });
+    const segmentBuffer = await (0, _nodewebstreamshelper.streamToBuffer)(segmentStream);
+    if (key === _segmentvalueencoding.ROOT_SEGMENT_KEY) {
+        return [
+            '/_index',
+            segmentBuffer
+        ];
+    } else {
+        return [
+            key,
+            segmentBuffer
+        ];
+    }
+}
+async function isPartialRSCData(rsc, clientModules) {
+    // We can determine if a segment contains only partial data if it takes longer
+    // than a task to encode, because dynamic data is encoded as an infinite
+    // promise. We must do this in a separate Flight prerender from the one that
+    // actually generates the prefetch stream because we need to include
+    // `isPartial` in the stream itself.
+    let isPartial = false;
+    const abortController = new AbortController();
+    (0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>{
+        // If we haven't yet finished the outer task, then it must be because we
+        // accessed dynamic data.
+        isPartial = true;
+        abortController.abort();
+    });
+    await (0, _staticedge.unstable_prerender)(rsc, clientModules, {
+        signal: abortController.signal,
+        onError () {}
+    });
+    return isPartial;
+}
+function createUnclosingPrefetchStream(originalFlightStream) {
+    // When PPR is enabled, prefetch streams may contain references that never
+    // resolve, because that's how we encode dynamic data access. In the decoded
+    // object returned by the Flight client, these are reified into hanging
+    // promises that suspend during render, which is effectively what we want.
+    // The UI resolves when it switches to the dynamic data stream
+    // (via useDeferredValue(dynamic, static)).
+    //
+    // However, the Flight implementation currently errors if the server closes
+    // the response before all the references are resolved. As a cheat to work
+    // around this, we wrap the original stream in a new stream that never closes,
+    // and therefore doesn't error.
+    const reader = originalFlightStream.getReader();
+    return new ReadableStream({
+        async pull (controller) {
+            while(true){
+                const { done, value } = await reader.read();
+                if (!done) {
+                    // Pass to the target stream and keep consuming the Flight response
+                    // from the server.
+                    controller.enqueue(value);
+                    continue;
+                }
+                // The server stream has closed. Exit, but intentionally do not close
+                // the target stream.
+                return;
+            }
+        }
+    });
+}
+
+//# sourceMappingURL=collect-segment-data.js.map

frontend/webapp/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { AppRenderContext } from './app-render';
+export declare function createComponentStylesAndScripts({ filePath, getComponent, injectedCSS, injectedJS, ctx, }: {
+    filePath: string;
+    getComponent: () => any;
+    injectedCSS: Set<string>;
+    injectedJS: Set<string>;
+    ctx: AppRenderContext;
+}): Promise<[React.ComponentType<any>, React.ReactNode, React.ReactNode]>;

frontend/webapp/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createComponentStylesAndScripts", {
+    enumerable: true,
+    get: function() {
+        return createComponentStylesAndScripts;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _interopdefault = require("./interop-default");
+const _getcssinlinedlinktags = require("./get-css-inlined-link-tags");
+const _getassetquerystring = require("./get-asset-query-string");
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _rendercssresource = require("./render-css-resource");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function createComponentStylesAndScripts({ filePath, getComponent, injectedCSS, injectedJS, ctx }) {
+    const { styles: entryCssFiles, scripts: jsHrefs } = (0, _getcssinlinedlinktags.getLinkAndScriptTags)(ctx.clientReferenceManifest, filePath, injectedCSS, injectedJS);
+    const styles = (0, _rendercssresource.renderCssResource)(entryCssFiles, ctx);
+    const scripts = jsHrefs ? jsHrefs.map((href, index)=>/*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+            src: `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`,
+            async: true
+        }, `script-${index}`)) : null;
+    const Comp = (0, _interopdefault.interopDefault)(await getComponent());
+    return [
+        Comp,
+        styles,
+        scripts
+    ];
+}
+
+//# sourceMappingURL=create-component-styles-and-scripts.js.map

frontend/webapp/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/create-component-styles-and-scripts.tsx"],"sourcesContent":["import React from 'react'\nimport { interopDefault } from './interop-default'\nimport { getLinkAndScriptTags } from './get-css-inlined-link-tags'\nimport type { AppRenderContext } from './app-render'\nimport { getAssetQueryString } from './get-asset-query-string'\nimport { encodeURIPath } from '../../shared/lib/encode-uri-path'\nimport { renderCssResource } from './render-css-resource'\n\nexport async function createComponentStylesAndScripts({\n  filePath,\n  getComponent,\n  injectedCSS,\n  injectedJS,\n  ctx,\n}: {\n  filePath: string\n  getComponent: () => any\n  injectedCSS: Set<string>\n  injectedJS: Set<string>\n  ctx: AppRenderContext\n}): Promise<[React.ComponentType<any>, React.ReactNode, React.ReactNode]> {\n  const { styles: entryCssFiles, scripts: jsHrefs } = getLinkAndScriptTags(\n    ctx.clientReferenceManifest,\n    filePath,\n    injectedCSS,\n    injectedJS\n  )\n\n  const styles = renderCssResource(entryCssFiles, ctx)\n\n  const scripts = jsHrefs\n    ? jsHrefs.map((href, index) => (\n        <script\n          src={`${ctx.assetPrefix}/_next/${encodeURIPath(\n            href\n          )}${getAssetQueryString(ctx, true)}`}\n          async={true}\n          key={`script-${index}`}\n        />\n      ))\n    : null\n\n  const Comp = interopDefault(await getComponent())\n\n  return [Comp, styles, scripts]\n}\n"],"names":["createComponentStylesAndScripts","filePath","getComponent","injectedCSS","injectedJS","ctx","styles","entryCssFiles","scripts","jsHrefs","getLinkAndScriptTags","clientReferenceManifest","renderCssResource","map","href","index","script","src","assetPrefix","encodeURIPath","getAssetQueryString","async","Comp","interopDefault"],"mappings":";;;;+BAQsBA;;;eAAAA;;;;8DARJ;gCACa;uCACM;qCAED;+BACN;mCACI;;;;;;AAE3B,eAAeA,gCAAgC,EACpDC,QAAQ,EACRC,YAAY,EACZC,WAAW,EACXC,UAAU,EACVC,GAAG,EAOJ;IACC,MAAM,EAAEC,QAAQC,aAAa,EAAEC,SAASC,OAAO,EAAE,GAAGC,IAAAA,2CAAoB,EACtEL,IAAIM,uBAAuB,EAC3BV,UACAE,aACAC;IAGF,MAAME,SAASM,IAAAA,oCAAiB,EAACL,eAAeF;IAEhD,MAAMG,UAAUC,UACZA,QAAQI,GAAG,CAAC,CAACC,MAAMC,sBACjB,qBAACC;YACCC,KAAK,GAAGZ,IAAIa,WAAW,CAAC,OAAO,EAAEC,IAAAA,4BAAa,EAC5CL,QACEM,IAAAA,wCAAmB,EAACf,KAAK,OAAO;YACpCgB,OAAO;WACF,CAAC,OAAO,EAAEN,OAAO,KAG1B;IAEJ,MAAMO,OAAOC,IAAAA,8BAAc,EAAC,MAAMrB;IAElC,OAAO;QAACoB;QAAMhB;QAAQE;KAAQ;AAChC"}

frontend/webapp/node_modules/next/dist/server/app-render/create-component-tree.d.ts

@@ -0,0 +1,25 @@
+import type { CacheNodeSeedData, PreloadCallbacks } from './types';
+import React from 'react';
+import type { LoaderTree } from '../lib/app-dir-module';
+import type { AppRenderContext, GetDynamicParamFromSegment } from './app-render';
+import type { Params } from '../request/params';
+/**
+ * Use the provided loader tree to create the React Component tree.
+ */
+export declare function createComponentTree(props: {
+    loaderTree: LoaderTree;
+    parentParams: Params;
+    rootLayoutIncluded: boolean;
+    injectedCSS: Set<string>;
+    injectedJS: Set<string>;
+    injectedFontPreloadTags: Set<string>;
+    getMetadataReady: () => Promise<void>;
+    getViewportReady: () => Promise<void>;
+    ctx: AppRenderContext;
+    missingSlots?: Set<string>;
+    preloadCallbacks: PreloadCallbacks;
+    authInterrupts: boolean;
+    StreamingMetadata: React.ComponentType | null;
+    StreamingMetadataOutlet: React.ComponentType;
+}): Promise<CacheNodeSeedData>;
+export declare function getRootParams(loaderTree: LoaderTree, getDynamicParamFromSegment: GetDynamicParamFromSegment): Params;

frontend/webapp/node_modules/next/dist/server/app-render/create-component-tree.js

@@ -0,0 +1,697 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createComponentTree: null,
+    getRootParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createComponentTree: function() {
+        return createComponentTree;
+    },
+    getRootParams: function() {
+        return getRootParams;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _clientandserverreferences = require("../../lib/client-and-server-references");
+const _appdirmodule = require("../lib/app-dir-module");
+const _interopdefault = require("./interop-default");
+const _parseloadertree = require("./parse-loader-tree");
+const _createcomponentstylesandscripts = require("./create-component-styles-and-scripts");
+const _getlayerassets = require("./get-layer-assets");
+const _hasloadingcomponentintree = require("./has-loading-component-in-tree");
+const _patchfetch = require("../lib/patch-fetch");
+const _parallelroutedefault = require("../../client/components/parallel-route-default");
+const _tracer = require("../lib/trace/tracer");
+const _constants = require("../lib/trace/constants");
+const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+const _metadataconstants = require("../../lib/metadata/metadata-constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createComponentTree(props) {
+    return (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.createComponentTree, {
+        spanName: 'build component tree'
+    }, ()=>createComponentTreeInternal(props));
+}
+function errorMissingDefaultExport(pagePath, convention) {
+    const normalizedPagePath = pagePath === '/' ? '' : pagePath;
+    throw Object.defineProperty(new Error(`The default export is not a React Component in "${normalizedPagePath}/${convention}"`), "__NEXT_ERROR_CODE", {
+        value: "E45",
+        enumerable: false,
+        configurable: true
+    });
+}
+const cacheNodeKey = 'c';
+async function createComponentTreeInternal({ loaderTree: tree, parentParams, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, getViewportReady, getMetadataReady, ctx, missingSlots, preloadCallbacks, authInterrupts, StreamingMetadata, StreamingMetadataOutlet }) {
+    const { renderOpts: { nextConfigOutput, experimental }, workStore, componentMod: { HTTPAccessFallbackBoundary, LayoutRouter, RenderFromTemplateContext, OutletBoundary, ClientPageRoot, ClientSegmentRoot, createServerSearchParamsForServerPage, createPrerenderSearchParamsForClientPage, createServerParamsForServerSegment, createPrerenderParamsForClientSegment, serverHooks: { DynamicServerError }, Postpone }, pagePath, getDynamicParamFromSegment, isPrefetch, query } = ctx;
+    const { page, layoutOrPagePath, segment, modules, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    const { layout, template, error, loading, 'not-found': notFound, forbidden, unauthorized } = modules;
+    const injectedCSSWithCurrentLayout = new Set(injectedCSS);
+    const injectedJSWithCurrentLayout = new Set(injectedJS);
+    const injectedFontPreloadTagsWithCurrentLayout = new Set(injectedFontPreloadTags);
+    const layerAssets = (0, _getlayerassets.getLayerAssets)({
+        preloadCallbacks,
+        ctx,
+        layoutOrPagePath,
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout,
+        injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout
+    });
+    const [Template, templateStyles, templateScripts] = template ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: template[1],
+        getComponent: template[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [
+        _react.default.Fragment
+    ];
+    const [ErrorComponent, errorStyles, errorScripts] = error ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: error[1],
+        getComponent: error[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const [Loading, loadingStyles, loadingScripts] = loading ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: loading[1],
+        getComponent: loading[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const isLayout = typeof layout !== 'undefined';
+    const isPage = typeof page !== 'undefined';
+    const { mod: layoutOrPageMod, modType } = await (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.getLayoutOrPageModule, {
+        hideSpan: !(isLayout || isPage),
+        spanName: 'resolve segment modules',
+        attributes: {
+            'next.segment': segment
+        }
+    }, ()=>(0, _appdirmodule.getLayoutOrPageModule)(tree));
+    /**
+   * Checks if the current segment is a root layout.
+   */ const rootLayoutAtThisLevel = isLayout && !rootLayoutIncluded;
+    /**
+   * Checks if the current segment or any level above it has a root layout.
+   */ const rootLayoutIncludedAtThisLevelOrAbove = rootLayoutIncluded || rootLayoutAtThisLevel;
+    const [NotFound, notFoundStyles] = notFound ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: notFound[1],
+        getComponent: notFound[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const [Forbidden, forbiddenStyles] = authInterrupts && forbidden ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: forbidden[1],
+        getComponent: forbidden[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const [Unauthorized, unauthorizedStyles] = authInterrupts && unauthorized ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: unauthorized[1],
+        getComponent: unauthorized[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    let dynamic = layoutOrPageMod == null ? void 0 : layoutOrPageMod.dynamic;
+    if (nextConfigOutput === 'export') {
+        if (!dynamic || dynamic === 'auto') {
+            dynamic = 'error';
+        } else if (dynamic === 'force-dynamic') {
+            // force-dynamic is always incompatible with 'export'. We must interrupt the build
+            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Page with \`dynamic = "force-dynamic"\` couldn't be exported. \`output: "export"\` requires all pages be renderable statically because there is no runtime server to dynamically render routes in this output format. Learn more: https://nextjs.org/docs/app/building-your-application/deploying/static-exports`), "__NEXT_ERROR_CODE", {
+                value: "E527",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    if (typeof dynamic === 'string') {
+        // the nested most config wins so we only force-static
+        // if it's configured above any parent that configured
+        // otherwise
+        if (dynamic === 'error') {
+            workStore.dynamicShouldError = true;
+        } else if (dynamic === 'force-dynamic') {
+            workStore.forceDynamic = true;
+            // TODO: (PPR) remove this bailout once PPR is the default
+            if (workStore.isStaticGeneration && !experimental.isRoutePPREnabled) {
+                // If the postpone API isn't available, we can't postpone the render and
+                // therefore we can't use the dynamic API.
+                const err = Object.defineProperty(new DynamicServerError(`Page with \`dynamic = "force-dynamic"\` won't be rendered statically.`), "__NEXT_ERROR_CODE", {
+                    value: "E585",
+                    enumerable: false,
+                    configurable: true
+                });
+                workStore.dynamicUsageDescription = err.message;
+                workStore.dynamicUsageStack = err.stack;
+                throw err;
+            }
+        } else {
+            workStore.dynamicShouldError = false;
+            workStore.forceStatic = dynamic === 'force-static';
+        }
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.fetchCache) === 'string') {
+        workStore.fetchCache = layoutOrPageMod == null ? void 0 : layoutOrPageMod.fetchCache;
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate) !== 'undefined') {
+        (0, _patchfetch.validateRevalidate)(layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate, workStore.route);
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate) === 'number') {
+        const defaultRevalidate = layoutOrPageMod.revalidate;
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (workUnitStore) {
+            if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-legacy' || workUnitStore.type === 'prerender-ppr' || workUnitStore.type === 'cache') {
+                if (workUnitStore.revalidate > defaultRevalidate) {
+                    workUnitStore.revalidate = defaultRevalidate;
+                }
+            }
+        }
+        if (!workStore.forceStatic && workStore.isStaticGeneration && defaultRevalidate === 0 && // If the postpone API isn't available, we can't postpone the render and
+        // therefore we can't use the dynamic API.
+        !experimental.isRoutePPREnabled) {
+            const dynamicUsageDescription = `revalidate: 0 configured ${segment}`;
+            workStore.dynamicUsageDescription = dynamicUsageDescription;
+            throw Object.defineProperty(new DynamicServerError(dynamicUsageDescription), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    const isStaticGeneration = workStore.isStaticGeneration;
+    // Assume the segment we're rendering contains only partial data if PPR is
+    // enabled and this is a statically generated response. This is used by the
+    // client Segment Cache after a prefetch to determine if it can skip the
+    // second request to fill in the dynamic data.
+    //
+    // It's OK for this to be `true` when the data is actually fully static, but
+    // it's not OK for this to be `false` when the data possibly contains holes.
+    // Although the value here is overly pessimistic, for prefetches, it will be
+    // replaced by a more specific value when the data is later processed into
+    // per-segment responses (see collect-segment-data.tsx)
+    //
+    // For dynamic requests, this must always be `false` because dynamic responses
+    // are never partial.
+    const isPossiblyPartialResponse = isStaticGeneration && experimental.isRoutePPREnabled === true;
+    const LayoutOrPage = layoutOrPageMod ? (0, _interopdefault.interopDefault)(layoutOrPageMod) : undefined;
+    /**
+   * The React Component to render.
+   */ let MaybeComponent = LayoutOrPage;
+    if (process.env.NODE_ENV === 'development') {
+        const { isValidElementType } = require('next/dist/compiled/react-is');
+        if (typeof MaybeComponent !== 'undefined' && !isValidElementType(MaybeComponent)) {
+            errorMissingDefaultExport(pagePath, modType ?? 'page');
+        }
+        if (typeof ErrorComponent !== 'undefined' && !isValidElementType(ErrorComponent)) {
+            errorMissingDefaultExport(pagePath, 'error');
+        }
+        if (typeof Loading !== 'undefined' && !isValidElementType(Loading)) {
+            errorMissingDefaultExport(pagePath, 'loading');
+        }
+        if (typeof NotFound !== 'undefined' && !isValidElementType(NotFound)) {
+            errorMissingDefaultExport(pagePath, 'not-found');
+        }
+        if (typeof Forbidden !== 'undefined' && !isValidElementType(Forbidden)) {
+            errorMissingDefaultExport(pagePath, 'forbidden');
+        }
+        if (typeof Unauthorized !== 'undefined' && !isValidElementType(Unauthorized)) {
+            errorMissingDefaultExport(pagePath, 'unauthorized');
+        }
+    }
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    // Create object holding the parent params and current params
+    let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    // Resolve the segment param
+    const actualSegment = segmentParam ? segmentParam.treeSegment : segment;
+    const metadata = StreamingMetadata ? /*#__PURE__*/ (0, _jsxruntime.jsx)(StreamingMetadata, {}) : undefined;
+    // Use the same condition to render metadataOutlet as metadata
+    const metadataOutlet = StreamingMetadataOutlet ? /*#__PURE__*/ (0, _jsxruntime.jsx)(StreamingMetadataOutlet, {}) : undefined;
+    const notFoundElement = NotFound ? /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFound, {}),
+            notFoundStyles
+        ]
+    }) : undefined;
+    const forbiddenElement = Forbidden ? /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(Forbidden, {}),
+            forbiddenStyles
+        ]
+    }) : undefined;
+    const unauthorizedElement = Unauthorized ? /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(Unauthorized, {}),
+            unauthorizedStyles
+        ]
+    }) : undefined;
+    // TODO: Combine this `map` traversal with the loop below that turns the array
+    // into an object.
+    const parallelRouteMap = await Promise.all(Object.keys(parallelRoutes).map(async (parallelRouteKey)=>{
+        const isChildrenRouteKey = parallelRouteKey === 'children';
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const notFoundComponent = isChildrenRouteKey ? notFoundElement : undefined;
+        const forbiddenComponent = isChildrenRouteKey ? forbiddenElement : undefined;
+        const unauthorizedComponent = isChildrenRouteKey ? unauthorizedElement : undefined;
+        // if we're prefetching and that there's a Loading component, we bail out
+        // otherwise we keep rendering for the prefetch.
+        // We also want to bail out if there's no Loading component in the tree.
+        let childCacheNodeSeedData = null;
+        if (// Before PPR, the way instant navigations work in Next.js is we
+        // prefetch everything up to the first route segment that defines a
+        // loading.tsx boundary. (We do the same if there's no loading
+        // boundary in the entire tree, because we don't want to prefetch too
+        // much) The rest of the tree is deferred until the actual navigation.
+        // It does not take into account whether the data is dynamic — even if
+        // the tree is completely static, it will still defer everything
+        // inside the loading boundary.
+        //
+        // This behavior predates PPR and is only relevant if the
+        // PPR flag is not enabled.
+        isPrefetch && (Loading || !(0, _hasloadingcomponentintree.hasLoadingComponentInTree)(parallelRoute)) && // The approach with PPR is different — loading.tsx behaves like a
+        // regular Suspense boundary and has no special behavior.
+        //
+        // With PPR, we prefetch as deeply as possible, and only defer when
+        // dynamic data is accessed. If so, we only defer the nearest parent
+        // Suspense boundary of the dynamic data access, regardless of whether
+        // the boundary is defined by loading.tsx or a normal <Suspense>
+        // component in userspace.
+        //
+        // NOTE: In practice this usually means we'll end up prefetching more
+        // than we were before PPR, which may or may not be considered a
+        // performance regression by some apps. The plan is to address this
+        // before General Availability of PPR by introducing granular
+        // per-segment fetching, so we can reuse as much of the tree as
+        // possible during both prefetches and dynamic navigations. But during
+        // the beta period, we should be clear about this trade off in our
+        // communications.
+        !experimental.isRoutePPREnabled) {
+        // Don't prefetch this child. This will trigger a lazy fetch by the
+        // client router.
+        } else {
+            // Create the child component
+            if (process.env.NODE_ENV === 'development' && missingSlots) {
+                var _parsedTree_layoutOrPagePath;
+                // When we detect the default fallback (which triggers a 404), we collect the missing slots
+                // to provide more helpful debug information during development mode.
+                const parsedTree = (0, _parseloadertree.parseLoaderTree)(parallelRoute);
+                if ((_parsedTree_layoutOrPagePath = parsedTree.layoutOrPagePath) == null ? void 0 : _parsedTree_layoutOrPagePath.endsWith(_parallelroutedefault.PARALLEL_ROUTE_DEFAULT_PATH)) {
+                    missingSlots.add(parallelRouteKey);
+                }
+            }
+            const seedData = await createComponentTreeInternal({
+                loaderTree: parallelRoute,
+                parentParams: currentParams,
+                rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
+                injectedCSS: injectedCSSWithCurrentLayout,
+                injectedJS: injectedJSWithCurrentLayout,
+                injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout,
+                // `getMetadataReady` and `getViewportReady` are used to conditionally throw. In the case of parallel routes we will have more than one page
+                // but we only want to throw on the first one.
+                getMetadataReady: isChildrenRouteKey ? getMetadataReady : ()=>Promise.resolve(),
+                getViewportReady: isChildrenRouteKey ? getViewportReady : ()=>Promise.resolve(),
+                ctx,
+                missingSlots,
+                preloadCallbacks,
+                authInterrupts,
+                StreamingMetadata: isChildrenRouteKey ? StreamingMetadata : null,
+                // `StreamingMetadataOutlet` is used to conditionally throw. In the case of parallel routes we will have more than one page
+                // but we only want to throw on the first one.
+                StreamingMetadataOutlet: isChildrenRouteKey ? StreamingMetadataOutlet : null
+            });
+            childCacheNodeSeedData = seedData;
+        }
+        // This is turned back into an object below.
+        return [
+            parallelRouteKey,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(LayoutRouter, {
+                parallelRouterKey: parallelRouteKey,
+                // TODO-APP: Add test for loading returning `undefined`. This currently can't be tested as the `webdriver()` tab will wait for the full page to load before returning.
+                error: ErrorComponent,
+                errorStyles: errorStyles,
+                errorScripts: errorScripts,
+                template: /*#__PURE__*/ (0, _jsxruntime.jsx)(Template, {
+                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(RenderFromTemplateContext, {})
+                }),
+                templateStyles: templateStyles,
+                templateScripts: templateScripts,
+                notFound: notFoundComponent,
+                forbidden: forbiddenComponent,
+                unauthorized: unauthorizedComponent
+            }),
+            childCacheNodeSeedData
+        ];
+    }));
+    // Convert the parallel route map into an object after all promises have been resolved.
+    let parallelRouteProps = {};
+    let parallelRouteCacheNodeSeedData = {};
+    for (const parallelRoute of parallelRouteMap){
+        const [parallelRouteKey, parallelRouteProp, flightData] = parallelRoute;
+        parallelRouteProps[parallelRouteKey] = parallelRouteProp;
+        parallelRouteCacheNodeSeedData[parallelRouteKey] = flightData;
+    }
+    const loadingData = Loading ? [
+        /*#__PURE__*/ (0, _jsxruntime.jsx)(Loading, {}, "l"),
+        loadingStyles,
+        loadingScripts
+    ] : null;
+    // When the segment does not have a layout or page we still have to add the layout router to ensure the path holds the loading component
+    if (!MaybeComponent) {
+        return [
+            actualSegment,
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                children: [
+                    layerAssets,
+                    parallelRouteProps.children
+                ]
+            }, cacheNodeKey),
+            parallelRouteCacheNodeSeedData,
+            loadingData,
+            isPossiblyPartialResponse
+        ];
+    }
+    const Component = MaybeComponent;
+    // If force-dynamic is used and the current render supports postponing, we
+    // replace it with a node that will postpone the render. This ensures that the
+    // postpone is invoked during the react render phase and not during the next
+    // render phase.
+    // @TODO this does not actually do what it seems like it would or should do. The idea is that
+    // if we are rendering in a force-dynamic mode and we can postpone we should only make the segments
+    // that ask for force-dynamic to be dynamic, allowing other segments to still prerender. However
+    // because this comes after the children traversal and the static generation store is mutated every segment
+    // along the parent path of a force-dynamic segment will hit this condition effectively making the entire
+    // render force-dynamic. We should refactor this function so that we can correctly track which segments
+    // need to be dynamic
+    if (workStore.isStaticGeneration && workStore.forceDynamic && experimental.isRoutePPREnabled) {
+        return [
+            actualSegment,
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(Postpone, {
+                        reason: 'dynamic = "force-dynamic" was used',
+                        route: workStore.route
+                    }),
+                    layerAssets
+                ]
+            }, cacheNodeKey),
+            parallelRouteCacheNodeSeedData,
+            loadingData,
+            true
+        ];
+    }
+    const isClientComponent = (0, _clientandserverreferences.isClientReference)(layoutOrPageMod);
+    if (process.env.NODE_ENV === 'development' && 'params' in parallelRouteProps) {
+        // @TODO consider making this an error and running the check in build as well
+        console.error(`"params" is a reserved prop in Layouts and Pages and cannot be used as the name of a parallel route in ${segment}`);
+    }
+    if (isPage) {
+        const PageComponent = Component;
+        // Assign searchParams to props if this is a page
+        let pageElement;
+        if (isClientComponent) {
+            if (isStaticGeneration) {
+                const promiseOfParams = createPrerenderParamsForClientSegment(currentParams, workStore);
+                const promiseOfSearchParams = createPrerenderSearchParamsForClientPage(workStore);
+                pageElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientPageRoot, {
+                    Component: PageComponent,
+                    searchParams: query,
+                    params: currentParams,
+                    promises: [
+                        promiseOfSearchParams,
+                        promiseOfParams
+                    ]
+                });
+            } else {
+                pageElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientPageRoot, {
+                    Component: PageComponent,
+                    searchParams: query,
+                    params: currentParams
+                });
+            }
+        } else {
+            // If we are passing params to a server component Page we need to track
+            // their usage in case the current render mode tracks dynamic API usage.
+            const params = createServerParamsForServerSegment(currentParams, workStore);
+            // TODO(useCache): Should we use this trick also if dynamicIO is enabled,
+            // instead of relying on the searchParams being a hanging promise?
+            if (!experimental.dynamicIO && (0, _clientandserverreferences.isUseCacheFunction)(PageComponent)) {
+                const UseCachePageComponent = PageComponent;
+                // The "use cache" wrapper takes care of converting this into an
+                // erroring search params promise when passing it to the original
+                // function.
+                const searchParams = Promise.resolve({});
+                pageElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(UseCachePageComponent, {
+                    params: params,
+                    searchParams: searchParams,
+                    $$isPageComponent: true
+                });
+            } else {
+                // If we are passing searchParams to a server component Page we need to
+                // track their usage in case the current render mode tracks dynamic API
+                // usage.
+                const searchParams = createServerSearchParamsForServerPage(query, workStore);
+                pageElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(PageComponent, {
+                    params: params,
+                    searchParams: searchParams
+                });
+            }
+        }
+        return [
+            actualSegment,
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                children: [
+                    pageElement,
+                    metadata,
+                    layerAssets,
+                    /*#__PURE__*/ (0, _jsxruntime.jsxs)(OutletBoundary, {
+                        children: [
+                            /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataOutlet, {
+                                ready: getViewportReady
+                            }),
+                            /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataOutlet, {
+                                ready: getMetadataReady
+                            }),
+                            metadataOutlet
+                        ]
+                    })
+                ]
+            }, cacheNodeKey),
+            parallelRouteCacheNodeSeedData,
+            loadingData,
+            isPossiblyPartialResponse
+        ];
+    } else {
+        const SegmentComponent = Component;
+        const isRootLayoutWithChildrenSlotAndAtLeastOneMoreSlot = rootLayoutAtThisLevel && 'children' in parallelRoutes && Object.keys(parallelRoutes).length > 1;
+        let segmentNode;
+        if (isClientComponent) {
+            let clientSegment;
+            if (isStaticGeneration) {
+                const promiseOfParams = createPrerenderParamsForClientSegment(currentParams, workStore);
+                clientSegment = /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientSegmentRoot, {
+                    Component: SegmentComponent,
+                    slots: parallelRouteProps,
+                    params: currentParams,
+                    promise: promiseOfParams
+                });
+            } else {
+                clientSegment = /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientSegmentRoot, {
+                    Component: SegmentComponent,
+                    slots: parallelRouteProps,
+                    params: currentParams
+                });
+            }
+            if (isRootLayoutWithChildrenSlotAndAtLeastOneMoreSlot) {
+                let notfoundClientSegment;
+                let forbiddenClientSegment;
+                let unauthorizedClientSegment;
+                // TODO-APP: This is a hack to support unmatched parallel routes, which will throw `notFound()`.
+                // This ensures that a `HTTPAccessFallbackBoundary` is available for when that happens,
+                // but it's not ideal, as it needlessly invokes the `NotFound` component and renders the `RootLayout` twice.
+                // We should instead look into handling the fallback behavior differently in development mode so that it doesn't
+                // rely on the `NotFound` behavior.
+                notfoundClientSegment = createErrorBoundaryClientSegmentRoot({
+                    ErrorBoundaryComponent: NotFound,
+                    errorElement: notFoundElement,
+                    ClientSegmentRoot,
+                    layerAssets,
+                    SegmentComponent,
+                    currentParams
+                });
+                forbiddenClientSegment = createErrorBoundaryClientSegmentRoot({
+                    ErrorBoundaryComponent: Forbidden,
+                    errorElement: forbiddenElement,
+                    ClientSegmentRoot,
+                    layerAssets,
+                    SegmentComponent,
+                    currentParams
+                });
+                unauthorizedClientSegment = createErrorBoundaryClientSegmentRoot({
+                    ErrorBoundaryComponent: Unauthorized,
+                    errorElement: unauthorizedElement,
+                    ClientSegmentRoot,
+                    layerAssets,
+                    SegmentComponent,
+                    currentParams
+                });
+                if (notfoundClientSegment || forbiddenClientSegment || unauthorizedClientSegment) {
+                    segmentNode = /*#__PURE__*/ (0, _jsxruntime.jsxs)(HTTPAccessFallbackBoundary, {
+                        notFound: notfoundClientSegment,
+                        forbidden: forbiddenClientSegment,
+                        unauthorized: unauthorizedClientSegment,
+                        children: [
+                            layerAssets,
+                            clientSegment
+                        ]
+                    }, cacheNodeKey);
+                } else {
+                    segmentNode = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                        children: [
+                            layerAssets,
+                            clientSegment
+                        ]
+                    }, cacheNodeKey);
+                }
+            } else {
+                segmentNode = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                    children: [
+                        layerAssets,
+                        clientSegment
+                    ]
+                }, cacheNodeKey);
+            }
+        } else {
+            const params = createServerParamsForServerSegment(currentParams, workStore);
+            let serverSegment = /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentComponent, {
+                ...parallelRouteProps,
+                params: params
+            });
+            if (isRootLayoutWithChildrenSlotAndAtLeastOneMoreSlot) {
+                // TODO-APP: This is a hack to support unmatched parallel routes, which will throw `notFound()`.
+                // This ensures that a `HTTPAccessFallbackBoundary` is available for when that happens,
+                // but it's not ideal, as it needlessly invokes the `NotFound` component and renders the `RootLayout` twice.
+                // We should instead look into handling the fallback behavior differently in development mode so that it doesn't
+                // rely on the `NotFound` behavior.
+                segmentNode = /*#__PURE__*/ (0, _jsxruntime.jsxs)(HTTPAccessFallbackBoundary, {
+                    notFound: NotFound ? /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                        children: [
+                            layerAssets,
+                            /*#__PURE__*/ (0, _jsxruntime.jsxs)(SegmentComponent, {
+                                params: params,
+                                children: [
+                                    notFoundStyles,
+                                    /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFound, {})
+                                ]
+                            })
+                        ]
+                    }) : undefined,
+                    children: [
+                        layerAssets,
+                        serverSegment
+                    ]
+                }, cacheNodeKey);
+            } else {
+                segmentNode = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                    children: [
+                        layerAssets,
+                        serverSegment
+                    ]
+                }, cacheNodeKey);
+            }
+        }
+        // For layouts we just render the component
+        return [
+            actualSegment,
+            segmentNode,
+            parallelRouteCacheNodeSeedData,
+            loadingData,
+            isPossiblyPartialResponse
+        ];
+    }
+}
+async function MetadataOutlet({ ready }) {
+    const r = ready();
+    // We can avoid a extra microtask by unwrapping the instrumented promise directly if available.
+    if (r.status === 'rejected') {
+        throw r.value;
+    } else if (r.status !== 'fulfilled') {
+        await r;
+    }
+    return null;
+}
+MetadataOutlet.displayName = _metadataconstants.OUTLET_BOUNDARY_NAME;
+function createErrorBoundaryClientSegmentRoot({ ErrorBoundaryComponent, errorElement, ClientSegmentRoot, layerAssets, SegmentComponent, currentParams }) {
+    if (ErrorBoundaryComponent) {
+        const notFoundParallelRouteProps = {
+            children: errorElement
+        };
+        return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+            children: [
+                layerAssets,
+                /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientSegmentRoot, {
+                    Component: SegmentComponent,
+                    slots: notFoundParallelRouteProps,
+                    params: currentParams
+                })
+            ]
+        });
+    }
+    return null;
+}
+function getRootParams(loaderTree, getDynamicParamFromSegment) {
+    return getRootParamsImpl({}, loaderTree, getDynamicParamFromSegment);
+}
+function getRootParamsImpl(parentParams, loaderTree, getDynamicParamFromSegment) {
+    const { segment, modules: { layout }, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(loaderTree);
+    const segmentParam = getDynamicParamFromSegment(segment);
+    let currentParams = parentParams;
+    if (segmentParam && segmentParam.value !== null) {
+        currentParams = {
+            ...parentParams,
+            [segmentParam.param]: segmentParam.value
+        };
+    }
+    const isRootLayout = typeof layout !== 'undefined';
+    if (isRootLayout) {
+        return currentParams;
+    } else if (!parallelRoutes.children) {
+        // This should really be an error but there are bugs in Turbopack that cause
+        // the _not-found LoaderTree to not have any layouts. For rootParams sake
+        // this is somewhat irrelevant when you are not customizing the 404 page.
+        // If you are customizing 404
+        // TODO update rootParams to make all params optional if `/app/not-found.tsx` is defined
+        return currentParams;
+    } else {
+        return getRootParamsImpl(currentParams, // We stop looking for root params as soon as we hit the first layout
+        // and it is not possible to use parallel route children above the root layout
+        // so every parallelRoutes object that this function can visit will necessarily
+        // have a single `children` prop and no others.
+        parallelRoutes.children, getDynamicParamFromSegment);
+    }
+}
+
+//# sourceMappingURL=create-component-tree.js.map

frontend/webapp/node_modules/next/dist/server/app-render/create-error-handler.d.ts

@@ -0,0 +1,20 @@
+import type { ErrorInfo } from 'react';
+declare global {
+    var __next_log_error__: undefined | ((err: unknown) => void);
+}
+type RSCErrorHandler = (err: unknown) => string | undefined;
+type SSRErrorHandler = (err: unknown, errorInfo?: ErrorInfo) => string | undefined;
+export type DigestedError = Error & {
+    digest: string;
+};
+/**
+ * Returns a digest for well-known Next.js errors, otherwise `undefined`. If a
+ * digest is returned this also means that the error does not need to be
+ * reported.
+ */
+export declare function getDigestForWellKnownError(error: unknown): string | undefined;
+export declare function createFlightReactServerErrorHandler(shouldFormatError: boolean, onReactServerRenderError: (err: DigestedError) => void): RSCErrorHandler;
+export declare function createHTMLReactServerErrorHandler(shouldFormatError: boolean, isNextExport: boolean, reactServerErrors: Map<string, DigestedError>, silenceLogger: boolean, onReactServerRenderError: undefined | ((err: DigestedError) => void)): RSCErrorHandler;
+export declare function createHTMLErrorHandler(shouldFormatError: boolean, isNextExport: boolean, reactServerErrors: Map<string, DigestedError>, allCapturedErrors: Array<unknown>, silenceLogger: boolean, onHTMLRenderSSRError: (err: DigestedError, errorInfo?: ErrorInfo) => void): SSRErrorHandler;
+export declare function isUserLandError(err: any): boolean;
+export {};

frontend/webapp/node_modules/next/dist/server/app-render/create-error-handler.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createFlightReactServerErrorHandler: null,
+    createHTMLErrorHandler: null,
+    createHTMLReactServerErrorHandler: null,
+    getDigestForWellKnownError: null,
+    isUserLandError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createFlightReactServerErrorHandler: function() {
+        return createFlightReactServerErrorHandler;
+    },
+    createHTMLErrorHandler: function() {
+        return createHTMLErrorHandler;
+    },
+    createHTMLReactServerErrorHandler: function() {
+        return createHTMLReactServerErrorHandler;
+    },
+    getDigestForWellKnownError: function() {
+        return getDigestForWellKnownError;
+    },
+    isUserLandError: function() {
+        return isUserLandError;
+    }
+});
+const _stringhash = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/string-hash"));
+const _formatservererror = require("../../lib/format-server-error");
+const _tracer = require("../lib/trace/tracer");
+const _pipereadable = require("../pipe-readable");
+const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _hooksservercontext = require("../../client/components/hooks-server-context");
+const _isnextroutererror = require("../../client/components/is-next-router-error");
+const _iserror = require("../../lib/is-error");
+const _errortelemetryutils = require("../../lib/error-telemetry-utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getDigestForWellKnownError(error) {
+    // If we're bailing out to CSR, we don't need to log the error.
+    if ((0, _bailouttocsr.isBailoutToCSRError)(error)) return error.digest;
+    // If this is a navigation error, we don't need to log the error.
+    if ((0, _isnextroutererror.isNextRouterError)(error)) return error.digest;
+    // If this error occurs, we know that we should be stopping the static
+    // render. This is only thrown in static generation when PPR is not enabled,
+    // which causes the whole page to be marked as dynamic. We don't need to
+    // tell the user about this error, as it's not actionable.
+    if ((0, _hooksservercontext.isDynamicServerError)(error)) return error.digest;
+    return undefined;
+}
+function createFlightReactServerErrorHandler(shouldFormatError, onReactServerRenderError) {
+    return (thrownValue)=>{
+        if (typeof thrownValue === 'string') {
+            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            return (0, _stringhash.default)(thrownValue).toString();
+        }
+        // If the response was closed, we don't need to log the error.
+        if ((0, _pipereadable.isAbortError)(thrownValue)) return;
+        const digest = getDigestForWellKnownError(thrownValue);
+        if (digest) {
+            return digest;
+        }
+        const err = (0, _iserror.getProperError)(thrownValue);
+        // If the error already has a digest, respect the original digest,
+        // so it won't get re-generated into another new error.
+        if (!err.digest) {
+            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            err.digest = (0, _stringhash.default)(err.message + err.stack || '').toString();
+        }
+        // Format server errors in development to add more helpful error messages
+        if (shouldFormatError) {
+            (0, _formatservererror.formatServerError)(err);
+        }
+        // Record exception in an active span, if available.
+        const span = (0, _tracer.getTracer)().getActiveScopeSpan();
+        if (span) {
+            span.recordException(err);
+            span.setStatus({
+                code: _tracer.SpanStatusCode.ERROR,
+                message: err.message
+            });
+        }
+        onReactServerRenderError(err);
+        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
+    };
+}
+function createHTMLReactServerErrorHandler(shouldFormatError, isNextExport, reactServerErrors, silenceLogger, onReactServerRenderError) {
+    return (thrownValue)=>{
+        var _err_message;
+        if (typeof thrownValue === 'string') {
+            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            return (0, _stringhash.default)(thrownValue).toString();
+        }
+        // If the response was closed, we don't need to log the error.
+        if ((0, _pipereadable.isAbortError)(thrownValue)) return;
+        const digest = getDigestForWellKnownError(thrownValue);
+        if (digest) {
+            return digest;
+        }
+        const err = (0, _iserror.getProperError)(thrownValue);
+        // If the error already has a digest, respect the original digest,
+        // so it won't get re-generated into another new error.
+        if (!err.digest) {
+            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            err.digest = (0, _stringhash.default)(err.message + (err.stack || '')).toString();
+        }
+        // @TODO by putting this here and not at the top it is possible that
+        // we don't error the build in places we actually expect to
+        if (!reactServerErrors.has(err.digest)) {
+            reactServerErrors.set(err.digest, err);
+        }
+        // Format server errors in development to add more helpful error messages
+        if (shouldFormatError) {
+            (0, _formatservererror.formatServerError)(err);
+        }
+        // Don't log the suppressed error during export
+        if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
+            // Record exception in an active span, if available.
+            const span = (0, _tracer.getTracer)().getActiveScopeSpan();
+            if (span) {
+                span.recordException(err);
+                span.setStatus({
+                    code: _tracer.SpanStatusCode.ERROR,
+                    message: err.message
+                });
+            }
+            if (!silenceLogger) {
+                onReactServerRenderError == null ? void 0 : onReactServerRenderError(err);
+            }
+        }
+        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
+    };
+}
+function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErrors, allCapturedErrors, silenceLogger, onHTMLRenderSSRError) {
+    return (thrownValue, errorInfo)=>{
+        var _err_message;
+        let isSSRError = true;
+        allCapturedErrors.push(thrownValue);
+        // If the response was closed, we don't need to log the error.
+        if ((0, _pipereadable.isAbortError)(thrownValue)) return;
+        const digest = getDigestForWellKnownError(thrownValue);
+        if (digest) {
+            return digest;
+        }
+        const err = (0, _iserror.getProperError)(thrownValue);
+        // If the error already has a digest, respect the original digest,
+        // so it won't get re-generated into another new error.
+        if (err.digest) {
+            if (reactServerErrors.has(err.digest)) {
+                // This error is likely an obfuscated error from react-server.
+                // We recover the original error here.
+                thrownValue = reactServerErrors.get(err.digest);
+                isSSRError = false;
+            } else {
+            // The error is not from react-server but has a digest
+            // from other means so we don't need to produce a new one
+            }
+        } else {
+            err.digest = (0, _stringhash.default)(err.message + ((errorInfo == null ? void 0 : errorInfo.componentStack) || err.stack || '')).toString();
+        }
+        // Format server errors in development to add more helpful error messages
+        if (shouldFormatError) {
+            (0, _formatservererror.formatServerError)(err);
+        }
+        // Don't log the suppressed error during export
+        if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
+            // Record exception in an active span, if available.
+            const span = (0, _tracer.getTracer)().getActiveScopeSpan();
+            if (span) {
+                span.recordException(err);
+                span.setStatus({
+                    code: _tracer.SpanStatusCode.ERROR,
+                    message: err.message
+                });
+            }
+            if (!silenceLogger && // HTML errors contain RSC errors as well, filter them out before reporting
+            isSSRError) {
+                onHTMLRenderSSRError(err, errorInfo);
+            }
+        }
+        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
+    };
+}
+function isUserLandError(err) {
+    return !(0, _pipereadable.isAbortError)(err) && !(0, _bailouttocsr.isBailoutToCSRError)(err) && !(0, _isnextroutererror.isNextRouterError)(err);
+}
+
+//# sourceMappingURL=create-error-handler.js.map

frontend/webapp/node_modules/next/dist/server/app-render/create-flight-router-state-from-loader-tree.d.ts

@@ -0,0 +1,4 @@
+import type { LoaderTree } from '../lib/app-dir-module';
+import type { FlightRouterState } from './types';
+import type { GetDynamicParamFromSegment } from './app-render';
+export declare function createFlightRouterStateFromLoaderTree([segment, parallelRoutes, { layout }]: LoaderTree, getDynamicParamFromSegment: GetDynamicParamFromSegment, searchParams: any, rootLayoutIncluded?: boolean): FlightRouterState;

frontend/webapp/node_modules/next/dist/server/app-render/create-flight-router-state-from-loader-tree.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createFlightRouterStateFromLoaderTree", {
+    enumerable: true,
+    get: function() {
+        return createFlightRouterStateFromLoaderTree;
+    }
+});
+const _segment = require("../../shared/lib/segment");
+function createFlightRouterStateFromLoaderTree([segment, parallelRoutes, { layout }], getDynamicParamFromSegment, searchParams, rootLayoutIncluded = false) {
+    const dynamicParam = getDynamicParamFromSegment(segment);
+    const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment;
+    const segmentTree = [
+        (0, _segment.addSearchParamsIfPageSegment)(treeSegment, searchParams),
+        {}
+    ];
+    if (!rootLayoutIncluded && typeof layout !== 'undefined') {
+        rootLayoutIncluded = true;
+        segmentTree[4] = true;
+    }
+    segmentTree[1] = Object.keys(parallelRoutes).reduce((existingValue, currentValue)=>{
+        existingValue[currentValue] = createFlightRouterStateFromLoaderTree(parallelRoutes[currentValue], getDynamicParamFromSegment, searchParams, rootLayoutIncluded);
+        return existingValue;
+    }, {});
+    return segmentTree;
+}
+
+//# sourceMappingURL=create-flight-router-state-from-loader-tree.js.map

frontend/webapp/node_modules/next/dist/server/app-render/create-flight-router-state-from-loader-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/create-flight-router-state-from-loader-tree.ts"],"sourcesContent":["import type { LoaderTree } from '../lib/app-dir-module'\nimport type { FlightRouterState } from './types'\nimport type { GetDynamicParamFromSegment } from './app-render'\nimport { addSearchParamsIfPageSegment } from '../../shared/lib/segment'\n\nexport function createFlightRouterStateFromLoaderTree(\n  [segment, parallelRoutes, { layout }]: LoaderTree,\n  getDynamicParamFromSegment: GetDynamicParamFromSegment,\n  searchParams: any,\n  rootLayoutIncluded = false\n): FlightRouterState {\n  const dynamicParam = getDynamicParamFromSegment(segment)\n  const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment\n\n  const segmentTree: FlightRouterState = [\n    addSearchParamsIfPageSegment(treeSegment, searchParams),\n    {},\n  ]\n\n  if (!rootLayoutIncluded && typeof layout !== 'undefined') {\n    rootLayoutIncluded = true\n    segmentTree[4] = true\n  }\n\n  segmentTree[1] = Object.keys(parallelRoutes).reduce(\n    (existingValue, currentValue) => {\n      existingValue[currentValue] = createFlightRouterStateFromLoaderTree(\n        parallelRoutes[currentValue],\n        getDynamicParamFromSegment,\n        searchParams,\n        rootLayoutIncluded\n      )\n      return existingValue\n    },\n    {} as FlightRouterState[1]\n  )\n\n  return segmentTree\n}\n"],"names":["createFlightRouterStateFromLoaderTree","segment","parallelRoutes","layout","getDynamicParamFromSegment","searchParams","rootLayoutIncluded","dynamicParam","treeSegment","segmentTree","addSearchParamsIfPageSegment","Object","keys","reduce","existingValue","currentValue"],"mappings":";;;;+BAKgBA;;;eAAAA;;;yBAF6B;AAEtC,SAASA,sCACd,CAACC,SAASC,gBAAgB,EAAEC,MAAM,EAAE,CAAa,EACjDC,0BAAsD,EACtDC,YAAiB,EACjBC,qBAAqB,KAAK;IAE1B,MAAMC,eAAeH,2BAA2BH;IAChD,MAAMO,cAAcD,eAAeA,aAAaC,WAAW,GAAGP;IAE9D,MAAMQ,cAAiC;QACrCC,IAAAA,qCAA4B,EAACF,aAAaH;QAC1C,CAAC;KACF;IAED,IAAI,CAACC,sBAAsB,OAAOH,WAAW,aAAa;QACxDG,qBAAqB;QACrBG,WAAW,CAAC,EAAE,GAAG;IACnB;IAEAA,WAAW,CAAC,EAAE,GAAGE,OAAOC,IAAI,CAACV,gBAAgBW,MAAM,CACjD,CAACC,eAAeC;QACdD,aAAa,CAACC,aAAa,GAAGf,sCAC5BE,cAAc,CAACa,aAAa,EAC5BX,4BACAC,cACAC;QAEF,OAAOQ;IACT,GACA,CAAC;IAGH,OAAOL;AACT"}

frontend/webapp/node_modules/next/dist/server/app-render/csrf-protection.d.ts

@@ -0,0 +1 @@
+export declare const isCsrfOriginAllowed: (originDomain: string, allowedOrigins?: string[]) => boolean;

frontend/webapp/node_modules/next/dist/server/app-render/csrf-protection.js

@@ -0,0 +1,74 @@
+// micromatch is only available at node runtime, so it cannot be used here since the code path that calls this function
+// can be run from edge. This is a simple implementation that safely achieves the required functionality.
+// the goal is to match the functionality for remotePatterns as defined here -
+// https://nextjs.org/docs/app/api-reference/components/image#remotepatterns
+// TODO - retrofit micromatch to work in edge and use that instead
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isCsrfOriginAllowed", {
+    enumerable: true,
+    get: function() {
+        return isCsrfOriginAllowed;
+    }
+});
+function matchWildcardDomain(domain, pattern) {
+    const domainParts = domain.split('.');
+    const patternParts = pattern.split('.');
+    if (patternParts.length < 1) {
+        // pattern is empty and therefore invalid to match against
+        return false;
+    }
+    if (domainParts.length < patternParts.length) {
+        // domain has too few segments and thus cannot match
+        return false;
+    }
+    // Prevent wildcards from matching entire domains (e.g. '**' or '*.com')
+    // This ensures wildcards can only match subdomains, not the main domain
+    if (patternParts.length === 1 && (patternParts[0] === '*' || patternParts[0] === '**')) {
+        return false;
+    }
+    while(patternParts.length){
+        const patternPart = patternParts.pop();
+        const domainPart = domainParts.pop();
+        switch(patternPart){
+            case '':
+                {
+                    // invalid pattern. pattern segments must be non empty
+                    return false;
+                }
+            case '*':
+                {
+                    // wildcard matches anything so we continue if the domain part is non-empty
+                    if (domainPart) {
+                        continue;
+                    } else {
+                        return false;
+                    }
+                }
+            case '**':
+                {
+                    // if this is not the last item in the pattern the pattern is invalid
+                    if (patternParts.length > 0) {
+                        return false;
+                    }
+                    // recursive wildcard matches anything so we terminate here if the domain part is non empty
+                    return domainPart !== undefined;
+                }
+            default:
+                {
+                    if (domainPart !== patternPart) {
+                        return false;
+                    }
+                }
+        }
+    }
+    // We exhausted the pattern. If we also exhausted the domain we have a match
+    return domainParts.length === 0;
+}
+const isCsrfOriginAllowed = (originDomain, allowedOrigins = [])=>{
+    return allowedOrigins.some((allowedOrigin)=>allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin)));
+};
+
+//# sourceMappingURL=csrf-protection.js.map

frontend/webapp/node_modules/next/dist/server/app-render/csrf-protection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/app-render/csrf-protection.ts"],"sourcesContent":["// micromatch is only available at node runtime, so it cannot be used here since the code path that calls this function\n// can be run from edge. This is a simple implementation that safely achieves the required functionality.\n// the goal is to match the functionality for remotePatterns as defined here -\n// https://nextjs.org/docs/app/api-reference/components/image#remotepatterns\n// TODO - retrofit micromatch to work in edge and use that instead\nfunction matchWildcardDomain(domain: string, pattern: string) {\n  const domainParts = domain.split('.')\n  const patternParts = pattern.split('.')\n\n  if (patternParts.length < 1) {\n    // pattern is empty and therefore invalid to match against\n    return false\n  }\n\n  if (domainParts.length < patternParts.length) {\n    // domain has too few segments and thus cannot match\n    return false\n  }\n\n  // Prevent wildcards from matching entire domains (e.g. '**' or '*.com')\n  // This ensures wildcards can only match subdomains, not the main domain\n  if (\n    patternParts.length === 1 &&\n    (patternParts[0] === '*' || patternParts[0] === '**')\n  ) {\n    return false\n  }\n\n  while (patternParts.length) {\n    const patternPart = patternParts.pop()\n    const domainPart = domainParts.pop()\n\n    switch (patternPart) {\n      case '': {\n        // invalid pattern. pattern segments must be non empty\n        return false\n      }\n      case '*': {\n        // wildcard matches anything so we continue if the domain part is non-empty\n        if (domainPart) {\n          continue\n        } else {\n          return false\n        }\n      }\n      case '**': {\n        // if this is not the last item in the pattern the pattern is invalid\n        if (patternParts.length > 0) {\n          return false\n        }\n        // recursive wildcard matches anything so we terminate here if the domain part is non empty\n        return domainPart !== undefined\n      }\n      default: {\n        if (domainPart !== patternPart) {\n          return false\n        }\n      }\n    }\n  }\n\n  // We exhausted the pattern. If we also exhausted the domain we have a match\n  return domainParts.length === 0\n}\n\nexport const isCsrfOriginAllowed = (\n  originDomain: string,\n  allowedOrigins: string[] = []\n): boolean => {\n  return allowedOrigins.some(\n    (allowedOrigin) =>\n      allowedOrigin &&\n      (allowedOrigin === originDomain ||\n        matchWildcardDomain(originDomain, allowedOrigin))\n  )\n}\n"],"names":["isCsrfOriginAllowed","matchWildcardDomain","domain","pattern","domainParts","split","patternParts","length","patternPart","pop","domainPart","undefined","originDomain","allowedOrigins","some","allowedOrigin"],"mappings":"AAAA,uHAAuH;AACvH,yGAAyG;AACzG,8EAA8E;AAC9E,4EAA4E;AAC5E,kEAAkE;;;;;+BA6DrDA;;;eAAAA;;;AA5Db,SAASC,oBAAoBC,MAAc,EAAEC,OAAe;IAC1D,MAAMC,cAAcF,OAAOG,KAAK,CAAC;IACjC,MAAMC,eAAeH,QAAQE,KAAK,CAAC;IAEnC,IAAIC,aAAaC,MAAM,GAAG,GAAG;QAC3B,0DAA0D;QAC1D,OAAO;IACT;IAEA,IAAIH,YAAYG,MAAM,GAAGD,aAAaC,MAAM,EAAE;QAC5C,oDAAoD;QACpD,OAAO;IACT;IAEA,wEAAwE;IACxE,wEAAwE;IACxE,IACED,aAAaC,MAAM,KAAK,KACvBD,CAAAA,YAAY,CAAC,EAAE,KAAK,OAAOA,YAAY,CAAC,EAAE,KAAK,IAAG,GACnD;QACA,OAAO;IACT;IAEA,MAAOA,aAAaC,MAAM,CAAE;QAC1B,MAAMC,cAAcF,aAAaG,GAAG;QACpC,MAAMC,aAAaN,YAAYK,GAAG;QAElC,OAAQD;YACN,KAAK;gBAAI;oBACP,sDAAsD;oBACtD,OAAO;gBACT;YACA,KAAK;gBAAK;oBACR,2EAA2E;oBAC3E,IAAIE,YAAY;wBACd;oBACF,OAAO;wBACL,OAAO;oBACT;gBACF;YACA,KAAK;gBAAM;oBACT,qEAAqE;oBACrE,IAAIJ,aAAaC,MAAM,GAAG,GAAG;wBAC3B,OAAO;oBACT;oBACA,2FAA2F;oBAC3F,OAAOG,eAAeC;gBACxB;YACA;gBAAS;oBACP,IAAID,eAAeF,aAAa;wBAC9B,OAAO;oBACT;gBACF;QACF;IACF;IAEA,4EAA4E;IAC5E,OAAOJ,YAAYG,MAAM,KAAK;AAChC;AAEO,MAAMP,sBAAsB,CACjCY,cACAC,iBAA2B,EAAE;IAE7B,OAAOA,eAAeC,IAAI,CACxB,CAACC,gBACCA,iBACCA,CAAAA,kBAAkBH,gBACjBX,oBAAoBW,cAAcG,cAAa;AAEvD"}

frontend/webapp/node_modules/next/dist/server/app-render/dynamic-rendering.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The functions provided by this module are used to communicate certain properties
+ * about the currently running code so that Next.js can make decisions on how to handle
+ * the current execution in different rendering modes such as pre-rendering, resuming, and SSR.
+ *
+ * Today Next.js treats all code as potentially static. Certain APIs may only make sense when dynamically rendering.
+ * Traditionally this meant deopting the entire render to dynamic however with PPR we can now deopt parts
+ * of a React tree as dynamic while still keeping other parts static. There are really two different kinds of
+ * Dynamic indications.
+ *
+ * The first is simply an intention to be dynamic. unstable_noStore is an example of this where
+ * the currently executing code simply declares that the current scope is dynamic but if you use it
+ * inside unstable_cache it can still be cached. This type of indication can be removed if we ever
+ * make the default dynamic to begin with because the only way you would ever be static is inside
+ * a cache scope which this indication does not affect.
+ *
+ * The second is an indication that a dynamic data source was read. This is a stronger form of dynamic
+ * because it means that it is inappropriate to cache this at all. using a dynamic data source inside
+ * unstable_cache should error. If you want to use some dynamic data inside unstable_cache you should
+ * read that data outside the cache and pass it in as an argument to the cached function.
+ */
+import type { WorkStore } from '../app-render/work-async-storage.external';
+import type { WorkUnitStore, RequestStore, PrerenderStoreModern } from '../app-render/work-unit-async-storage.external';
+export type DynamicAccess = {
+    /**
+     * If debugging, this will contain the stack trace of where the dynamic access
+     * occurred. This is used to provide more information to the user about why
+     * their page is being rendered dynamically.
+     */
+    stack?: string;
+    /**
+     * The expression that was accessed dynamically.
+     */
+    expression: string;
+};
+export type DynamicTrackingState = {
+    /**
+     * When true, stack information will also be tracked during dynamic access.
+     */
+    readonly isDebugDynamicAccesses: boolean | undefined;
+    /**
+     * The dynamic accesses that occurred during the render.
+     */
+    readonly dynamicAccesses: Array<DynamicAccess>;
+    syncDynamicExpression: undefined | string;
+    syncDynamicErrorWithStack: null | Error;
+    syncDynamicLogged?: boolean;
+};
+export type DynamicValidationState = {
+    hasSuspendedDynamic: boolean;
+    hasDynamicMetadata: boolean;
+    hasDynamicViewport: boolean;
+    hasSyncDynamicErrors: boolean;
+    dynamicErrors: Array<Error>;
+};
+export declare function createDynamicTrackingState(isDebugDynamicAccesses: boolean | undefined): DynamicTrackingState;
+export declare function createDynamicValidationState(): DynamicValidationState;
+export declare function getFirstDynamicReason(trackingState: DynamicTrackingState): undefined | string;
+/**
+ * This function communicates that the current scope should be treated as dynamic.
+ *
+ * In most cases this function is a no-op but if called during
+ * a PPR prerender it will postpone the current sub-tree and calling
+ * it during a normal prerender will cause the entire prerender to abort
+ */
+export declare function markCurrentScopeAsDynamic(store: WorkStore, workUnitStore: undefined | Exclude<WorkUnitStore, PrerenderStoreModern>, expression: string): void;
+/**
+ * This function communicates that some dynamic path parameter was read. This
+ * differs from the more general `trackDynamicDataAccessed` in that it is will
+ * not error when `dynamic = "error"` is set.
+ *
+ * @param store The static generation store
+ * @param expression The expression that was accessed dynamically
+ */
+export declare function trackFallbackParamAccessed(store: WorkStore, expression: string): void;
+export declare function abortOnSynchronousPlatformIOAccess(route: string, expression: string, errorWithStack: Error, prerenderStore: PrerenderStoreModern): void;
+export declare function trackSynchronousPlatformIOAccessInDev(requestStore: RequestStore): void;
+export declare const trackSynchronousRequestDataAccessInDev: typeof trackSynchronousPlatformIOAccessInDev;
+/**
+ * This component will call `React.postpone` that throws the postponed error.
+ */
+type PostponeProps = {
+    reason: string;
+    route: string;
+};
+export declare function Postpone({ reason, route }: PostponeProps): never;
+export declare function postponeWithTracking(route: string, expression: string, dynamicTracking: null | DynamicTrackingState): never;
+export declare function isDynamicPostpone(err: unknown): boolean;
+type DigestError = Error & {
+    digest: string;
+};
+export declare function isPrerenderInterruptedError(error: unknown): error is DigestError;
+export declare function accessedDynamicData(dynamicAccesses: Array<DynamicAccess>): boolean;
+export declare function consumeDynamicAccess(serverDynamic: DynamicTrackingState, clientDynamic: DynamicTrackingState): DynamicTrackingState['dynamicAccesses'];
+export declare function formatDynamicAPIAccesses(dynamicAccesses: Array<DynamicAccess>): string[];
+/**
+ * This is a bit of a hack to allow us to abort a render using a Postpone instance instead of an Error which changes React's
+ * abort semantics slightly.
+ */
+export declare function createPostponedAbortSignal(reason: string): AbortSignal;
+/**
+ * In a prerender, we may end up with hanging Promises as inputs due them
+ * stalling on connection() or because they're loading dynamic data. In that
+ * case we need to abort the encoding of arguments since they'll never complete.
+ */
+export declare function createHangingInputAbortSignal(workUnitStore: PrerenderStoreModern): AbortSignal;
+export declare function annotateDynamicAccess(expression: string, prerenderStore: PrerenderStoreModern): void;
+export declare function useDynamicRouteParams(expression: string): void;
+export declare function trackAllowedDynamicAccess(route: string, componentStack: string, dynamicValidation: DynamicValidationState, serverDynamic: DynamicTrackingState, clientDynamic: DynamicTrackingState): void;
+export declare function throwIfDisallowedDynamic(route: string, dynamicValidation: DynamicValidationState, serverDynamic: DynamicTrackingState, clientDynamic: DynamicTrackingState): void;
+export {};