business-stack 0.1.7 → 0.1.9

package/frontend/web/.next/standalone/node_modules/next/dist/lib/worker.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    Worker: null,
+    getNextBuildDebuggerPortOffset: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Worker: function() {
+        return Worker;
+    },
+    getNextBuildDebuggerPortOffset: function() {
+        return getNextBuildDebuggerPortOffset;
+    }
+});
+const _jestworker = require("next/dist/compiled/jest-worker");
+const _stream = require("stream");
+const _utils = require("../server/lib/utils");
+const RESTARTED = Symbol('restarted');
+const cleanupWorkers = (worker)=>{
+    var _worker__workerPool;
+    for (const curWorker of ((_worker__workerPool = worker._workerPool) == null ? void 0 : _worker__workerPool._workers) || []){
+        var _curWorker__child;
+        (_curWorker__child = curWorker._child) == null ? void 0 : _curWorker__child.kill('SIGINT');
+    }
+};
+function getNextBuildDebuggerPortOffset(_) {
+    // 0: export worker
+    return 0;
+}
+class Worker {
+    constructor(workerPath, options){
+        let { enableSourceMaps, timeout, onRestart, logger = console, debuggerPortOffset, isolatedMemory, onActivity, onActivityAbort, ...farmOptions } = options;
+        this._onActivity = onActivity;
+        this._onActivityAbort = onActivityAbort;
+        let restartPromise;
+        let resolveRestartPromise;
+        let activeTasks = 0;
+        this._worker = undefined;
+        // ensure we end workers if they weren't before exit
+        process.on('exit', ()=>{
+            this.close();
+        });
+        const nodeOptions = (0, _utils.getParsedNodeOptions)();
+        const originalOptions = {
+            ...nodeOptions
+        };
+        delete nodeOptions.inspect;
+        delete nodeOptions['inspect-brk'];
+        delete nodeOptions['inspect_brk'];
+        if (debuggerPortOffset !== -1) {
+            const nodeDebugType = (0, _utils.getNodeDebugType)(originalOptions);
+            if (nodeDebugType) {
+                const debuggerAddress = (0, _utils.getParsedDebugAddress)(originalOptions[nodeDebugType]);
+                const address = {
+                    host: debuggerAddress.host,
+                    // current process runs on `address.port`
+                    port: debuggerAddress.port === 0 ? 0 : debuggerAddress.port + 1 + debuggerPortOffset
+                };
+                nodeOptions[nodeDebugType] = (0, _utils.formatDebugAddress)(address);
+            }
+        }
+        if (enableSourceMaps) {
+            nodeOptions['enable-source-maps'] = true;
+        }
+        if (isolatedMemory) {
+            delete nodeOptions['max-old-space-size'];
+            delete nodeOptions['max_old_space_size'];
+        }
+        const { nodeOptions: formattedNodeOptions, execArgv } = (0, _utils.formatNodeOptions)(nodeOptions);
+        const createWorker = ()=>{
+            var _farmOptions_forkOptions, _farmOptions_forkOptions1;
+            const workerEnv = {
+                ...process.env,
+                ...((_farmOptions_forkOptions = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions.env) || {},
+                IS_NEXT_WORKER: 'true',
+                NODE_OPTIONS: formattedNodeOptions
+            };
+            if (workerEnv.FORCE_COLOR === undefined) {
+                var _process_stderr;
+                // Mirror the enablement heuristic from picocolors (see https://github.com/vercel/next.js/blob/6a40da0345939fe4f7b1ae519b296a86dd103432/packages/next/src/lib/picocolors.ts#L21-L24).
+                // Picocolors snapshots `process.env`/`stdout.isTTY` at module load time, so when the worker
+                // process bootstraps with piped stdio its own check would disable colors. Re-evaluating the
+                // same conditions here lets us opt the worker into color output only when the parent would
+                // have seen colors, while still respecting explicit opt-outs like NO_COLOR.
+                const supportsColors = !workerEnv.NO_COLOR && !workerEnv.CI && workerEnv.TERM !== 'dumb' && (process.stdout.isTTY || ((_process_stderr = process.stderr) == null ? void 0 : _process_stderr.isTTY));
+                if (supportsColors) {
+                    workerEnv.FORCE_COLOR = '1';
+                }
+            }
+            this._worker = new _jestworker.Worker(workerPath, {
+                ...farmOptions,
+                forkOptions: {
+                    ...farmOptions.forkOptions,
+                    execArgv: [
+                        ...execArgv,
+                        ...((_farmOptions_forkOptions1 = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions1.execArgv) || []
+                    ],
+                    env: workerEnv
+                },
+                maxRetries: 0
+            });
+            restartPromise = new Promise((resolve)=>resolveRestartPromise = resolve);
+            /**
+       * Jest Worker has two worker types, ChildProcessWorker (uses child_process) and NodeThreadWorker (uses worker_threads)
+       * Next.js uses ChildProcessWorker by default, but it can be switched to NodeThreadWorker with an experimental flag
+       *
+       * We only want to handle ChildProcessWorker's orphan process issue, so we access the private property "_child":
+       * https://github.com/facebook/jest/blob/b38d7d345a81d97d1dc3b68b8458b1837fbf19be/packages/jest-worker/src/workers/ChildProcessWorker.ts
+       *
+       * But this property is not available in NodeThreadWorker, so we need to check if we are using ChildProcessWorker
+       */ if (!farmOptions.enableWorkerThreads) {
+                var _this__worker__workerPool;
+                for (const worker of ((_this__worker__workerPool = this._worker._workerPool) == null ? void 0 : _this__worker__workerPool._workers) || []){
+                    var _worker__child, // if a child process emits a particular message, we track that as activity
+                    // so the parent process can keep track of progress
+                    _worker__child1;
+                    (_worker__child = worker._child) == null ? void 0 : _worker__child.on('exit', (code, signal)=>{
+                        if ((code || signal && signal !== 'SIGINT') && this._worker) {
+                            logger.error(`Next.js build worker exited with code: ${code} and signal: ${signal}`);
+                            // if a child process doesn't exit gracefully, we want to bubble up the exit code to the parent process
+                            process.exit(code ?? 1);
+                        }
+                    });
+                    (_worker__child1 = worker._child) == null ? void 0 : _worker__child1.on('message', ([, data])=>{
+                        if (data && typeof data === 'object' && 'type' in data && data.type === 'activity') {
+                            onActivityImpl();
+                        }
+                    });
+                }
+            }
+            let aborted = false;
+            const onActivityAbortImpl = ()=>{
+                if (!aborted) {
+                    this._onActivityAbort == null ? void 0 : this._onActivityAbort.call(this);
+                    aborted = true;
+                }
+            };
+            // Listen to the worker's stdout and stderr, if there's any thing logged, abort the activity first
+            const abortActivityStreamOnLog = new _stream.Transform({
+                transform (_chunk, _encoding, callback) {
+                    onActivityAbortImpl();
+                    callback();
+                }
+            });
+            // Stop the activity if there's any output from the worker
+            this._worker.getStdout().pipe(abortActivityStreamOnLog);
+            this._worker.getStderr().pipe(abortActivityStreamOnLog);
+            // Pipe the worker's stdout and stderr to the parent process
+            this._worker.getStdout().pipe(process.stdout);
+            this._worker.getStderr().pipe(process.stderr);
+        };
+        createWorker();
+        const onHanging = ()=>{
+            const worker = this._worker;
+            if (!worker) return;
+            const resolve = resolveRestartPromise;
+            createWorker();
+            logger.warn(`Sending SIGTERM signal to static worker due to timeout${timeout ? ` of ${timeout / 1000} seconds` : ''}. Subsequent errors may be a result of the worker exiting.`);
+            worker.end().then(()=>{
+                resolve(RESTARTED);
+            });
+        };
+        let hangingTimer = false;
+        const onActivityImpl = ()=>{
+            if (hangingTimer) clearTimeout(hangingTimer);
+            if (this._onActivity) this._onActivity();
+            hangingTimer = activeTasks > 0 && setTimeout(onHanging, timeout);
+        };
+        // TODO: Remove this once callers stop passing non-serializable values
+        // (e.g. functions) in worker method arguments. The structured clone
+        // algorithm used by worker_threads rejects functions, unlike
+        // child_process which silently drops them via JSON serialization.
+        const sanitizeArgs = farmOptions.enableWorkerThreads ? (args)=>JSON.parse(JSON.stringify(args)) : (args)=>args;
+        for (const method of farmOptions.exposedMethods){
+            if (method.startsWith('_')) continue;
+            this[method] = timeout ? async (...args)=>{
+                activeTasks++;
+                const sanitizedArgs = sanitizeArgs(args);
+                try {
+                    let attempts = 0;
+                    for(;;){
+                        onActivityImpl();
+                        const result = await Promise.race([
+                            this._worker[method](...sanitizedArgs),
+                            restartPromise
+                        ]);
+                        if (result !== RESTARTED) return result;
+                        if (onRestart) onRestart(method, sanitizedArgs, ++attempts);
+                    }
+                } finally{
+                    activeTasks--;
+                    onActivityImpl();
+                }
+            } : (...args)=>this._worker[method](...sanitizeArgs(args));
+        }
+    }
+    setOnActivity(onActivity) {
+        this._onActivity = onActivity;
+    }
+    setOnActivityAbort(onActivityAbort) {
+        this._onActivityAbort = onActivityAbort;
+    }
+    end() {
+        const worker = this._worker;
+        if (!worker) {
+            throw Object.defineProperty(new Error('Farm is ended, no more calls can be done to it'), "__NEXT_ERROR_CODE", {
+                value: "E265",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        cleanupWorkers(worker);
+        this._worker = undefined;
+        return worker.end();
+    }
+    /**
+   * Quietly end the worker if it exists
+   */ close() {
+        if (this._worker) {
+            cleanupWorkers(this._worker);
+            this._worker.end();
+        }
+    }
+}
+
+//# sourceMappingURL=worker.js.map

package/frontend/web/.next/standalone/node_modules/next/dist/server/ReactDOMServerPages.js

@@ -0,0 +1,16 @@
+"use strict";
+let ReactDOMServer;
+try {
+    // TODO: Use Node.js build unless we're in an Edge runtime.
+    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

package/frontend/web/.next/standalone/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

package/frontend/web/.next/standalone/node_modules/next/dist/server/after/after-context.js

@@ -0,0 +1,140 @@
+"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)(// WARNING: Don't make this a named function. It must be anonymous.
+        // See: https://github.com/facebook/react/pull/34911
+        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

package/frontend/web/.next/standalone/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

package/frontend/web/.next/standalone/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

package/frontend/web/.next/standalone/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

package/frontend/web/.next/standalone/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