putmein-test 1.0.0

package/dist/ray/node_modules/next/dist/server/dev/browser-logs/source-map.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getConsoleLocation: null,
+    getSourceMappedStackFrames: null,
+    mapFramesUsingBundler: null,
+    withLocation: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getConsoleLocation: function() {
+        return getConsoleLocation;
+    },
+    getSourceMappedStackFrames: function() {
+        return getSourceMappedStackFrames;
+    },
+    mapFramesUsingBundler: function() {
+        return mapFramesUsingBundler;
+    },
+    withLocation: function() {
+        return withLocation;
+    }
+});
+const _middlewarewebpack = require("../middleware-webpack");
+const _middlewareturbopack = require("../middleware-turbopack");
+const _picocolors = require("../../../lib/picocolors");
+const _parsestack = require("../../lib/parse-stack");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _lrucache = require("../../lib/lru-cache");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function mapFramesUsingBundler(frames, ctx) {
+    switch(ctx.bundler){
+        case 'webpack':
+            {
+                const { isServer, isEdgeServer, isAppDirectory, clientStats, serverStats, edgeServerStats, rootDirectory } = ctx;
+                const res = await (0, _middlewarewebpack.getOriginalStackFrames)({
+                    isServer,
+                    isEdgeServer,
+                    isAppDirectory,
+                    frames,
+                    clientStats,
+                    serverStats,
+                    edgeServerStats,
+                    rootDirectory
+                });
+                return res;
+            }
+        case 'turbopack':
+            {
+                const { project, projectPath, isServer, isEdgeServer, isAppDirectory } = ctx;
+                const res = await (0, _middlewareturbopack.getOriginalStackFrames)({
+                    project,
+                    projectPath,
+                    frames,
+                    isServer,
+                    isEdgeServer,
+                    isAppDirectory
+                });
+                return res;
+            }
+        default:
+            {
+                return null;
+            }
+    }
+}
+// converts _next/static/chunks/... to file:///.next/static/chunks/... for parseStack
+// todo: where does next dev overlay handle this case and re-use that logic
+function preprocessStackTrace(stackTrace, distDir) {
+    return stackTrace.split('\n').map((line)=>{
+        const match = line.match(/^(\s*at\s+.*?)\s+\(([^)]+)\)$/);
+        if (match) {
+            const [, prefix, location] = match;
+            if (location.startsWith('_next/static/') && distDir) {
+                const normalizedDistDir = distDir.replace(/\\/g, '/').replace(/\/$/, '');
+                const absolutePath = normalizedDistDir + '/' + location.slice('_next/'.length);
+                const fileUrl = `file://${_path.default.resolve(absolutePath)}`;
+                return `${prefix} (${fileUrl})`;
+            }
+        }
+        return line;
+    }).join('\n');
+}
+const cache = new _lrucache.LRUCache(25);
+async function getSourceMappedStackFramesInternal(stackTrace, ctx, distDir, ignore = true) {
+    try {
+        var _filteredFrames_find;
+        const normalizedStack = preprocessStackTrace(stackTrace, distDir);
+        const frames = (0, _parsestack.parseStack)(normalizedStack, distDir);
+        if (frames.length === 0) {
+            return {
+                kind: 'stack',
+                stack: stackTrace
+            };
+        }
+        const mappingResults = await mapFramesUsingBundler(frames, ctx);
+        const processedFrames = mappingResults.map((result, index)=>({
+                result,
+                originalFrame: frames[index]
+            })).map(({ result, originalFrame })=>{
+            var _originalStackFrame_file;
+            if (result.status === 'rejected') {
+                return {
+                    kind: 'rejected',
+                    frameText: formatStackFrame(originalFrame),
+                    codeFrame: null
+                };
+            }
+            const { originalStackFrame, originalCodeFrame } = result.value;
+            if ((originalStackFrame == null ? void 0 : originalStackFrame.ignored) && ignore) {
+                return {
+                    kind: 'ignored'
+                };
+            }
+            // should we apply this generally to dev overlay (dev overlay does not ignore chrome-extension://)
+            if (originalStackFrame == null ? void 0 : (_originalStackFrame_file = originalStackFrame.file) == null ? void 0 : _originalStackFrame_file.startsWith('chrome-extension://')) {
+                return {
+                    kind: 'ignored'
+                };
+            }
+            return {
+                kind: 'success',
+                // invariant: if result is not rejected and not ignored, then original stack frame exists
+                // verifiable by tracing `getOriginalStackFrame`. The invariant exists because of bad types
+                frameText: formatStackFrame(originalStackFrame),
+                codeFrame: originalCodeFrame
+            };
+        });
+        const allIgnored = processedFrames.every((frame)=>frame.kind === 'ignored');
+        // we want to handle **all** ignored vs all/some rejected differently
+        // if all are ignored we should show no frames
+        // if all are rejected, we want to fallback to showing original stack frames
+        if (allIgnored) {
+            return {
+                kind: 'all-ignored'
+            };
+        }
+        const filteredFrames = processedFrames.filter((frame)=>frame.kind !== 'ignored');
+        if (filteredFrames.length === 0) {
+            return {
+                kind: 'stack',
+                stack: stackTrace
+            };
+        }
+        const stackOutput = filteredFrames.map((frame)=>frame.frameText).join('\n');
+        const firstFrameCode = (_filteredFrames_find = filteredFrames.find((frame)=>frame.codeFrame)) == null ? void 0 : _filteredFrames_find.codeFrame;
+        if (firstFrameCode) {
+            return {
+                kind: 'with-frame-code',
+                frameCode: firstFrameCode,
+                stack: stackOutput,
+                frames: filteredFrames
+            };
+        }
+        // i don't think this a real case, but good for exhaustion
+        return {
+            kind: 'mapped-stack',
+            stack: stackOutput,
+            frames: filteredFrames
+        };
+    } catch (error) {
+        return {
+            kind: 'stack',
+            stack: stackTrace
+        };
+    }
+}
+async function getSourceMappedStackFrames(stackTrace, ctx, distDir, ignore = true) {
+    const cacheKey = `sm_${stackTrace}-${ctx.bundler}-${ctx.isAppDirectory}-${ctx.isEdgeServer}-${ctx.isServer}-${distDir}-${ignore}`;
+    const cacheItem = cache.get(cacheKey);
+    if (cacheItem) {
+        return cacheItem;
+    }
+    const result = await getSourceMappedStackFramesInternal(stackTrace, ctx, distDir, ignore);
+    cache.set(cacheKey, result);
+    return result;
+}
+function formatStackFrame(frame) {
+    const functionName = frame.methodName || '<anonymous>';
+    const location = frame.file && frame.line1 ? `${frame.file}:${frame.line1}${frame.column1 ? `:${frame.column1}` : ''}` : frame.file || '<unknown>';
+    return `    at ${functionName} (${location})`;
+}
+const withLocation = async ({ original, stack }, ctx, distDir, _config)=>{
+    if (!stack) {
+        return original;
+    }
+    const res = await getSourceMappedStackFrames(stack, ctx, distDir);
+    const location = getConsoleLocation(res);
+    if (!location) {
+        return original;
+    }
+    return [
+        ...original,
+        (0, _picocolors.dim)(`(${location})`)
+    ];
+};
+const getConsoleLocation = (mapped)=>{
+    if (mapped.kind !== 'mapped-stack' && mapped.kind !== 'with-frame-code') {
+        return null;
+    }
+    const first = mapped.frames.at(0);
+    if (!first) {
+        return null;
+    }
+    // we don't want to show the name of parent function (at <fn> thing in stack), just source location for minimal noise
+    const match = first.frameText.match(/\(([^)]+)\)/);
+    const locationText = match ? match[1] : first.frameText;
+    return locationText;
+};
+
+//# sourceMappingURL=source-map.js.map

package/dist/ray/node_modules/next/dist/server/dev/debug-channel.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    connectReactDebugChannel: null,
+    connectReactDebugChannelForHtmlRequest: null,
+    deleteReactDebugChannelForHtmlRequest: null,
+    setReactDebugChannelForHtmlRequest: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    connectReactDebugChannel: function() {
+        return connectReactDebugChannel;
+    },
+    connectReactDebugChannelForHtmlRequest: function() {
+        return connectReactDebugChannelForHtmlRequest;
+    },
+    deleteReactDebugChannelForHtmlRequest: function() {
+        return deleteReactDebugChannelForHtmlRequest;
+    },
+    setReactDebugChannelForHtmlRequest: function() {
+        return setReactDebugChannelForHtmlRequest;
+    }
+});
+const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _nodebufferedtransformstream = require("../stream-utils/node-buffered-transform-stream");
+const _hotreloadertypes = require("./hot-reloader-types");
+// Chunks are sent to the browser in batches to reduce overhead, flushing
+// synchronously once this many bytes have accumulated.
+const MAX_DEBUG_CHANNEL_BATCH_BYTES = 128 * 1024;
+const reactDebugChannelsByHtmlRequestId = new Map();
+function connectReactDebugChannel(requestId, debugChannel, sendToClient) {
+    let finished = false;
+    const stop = ()=>{
+        if (finished) {
+            return;
+        }
+        finished = true;
+        sendToClient({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK,
+            requestId,
+            chunk: null
+        });
+    };
+    const onError = (err)=>{
+        if (!finished) {
+            console.error(Object.defineProperty(new Error('React debug channel stream error', {
+                cause: err
+            }), "__NEXT_ERROR_CODE", {
+                value: "E810",
+                enumerable: false,
+                configurable: true
+            }));
+        }
+        stop();
+    };
+    const sendChunk = (chunk)=>{
+        sendToClient({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK,
+            requestId,
+            chunk
+        });
+    };
+    const { readable } = debugChannel;
+    if (readable instanceof ReadableStream) {
+        const reader = readable.pipeThrough((0, _nodewebstreamshelper.createBufferedTransformStream)({
+            maxBufferByteLength: MAX_DEBUG_CHANNEL_BATCH_BYTES
+        })).getReader();
+        const progress = (entry)=>{
+            if (entry.done) {
+                stop();
+            } else {
+                sendChunk(entry.value);
+                reader.read().then(progress, onError);
+            }
+        };
+        reader.read().then(progress, onError);
+    } else {
+        const source = readable;
+        // `pipe` does not forward source errors to the destination, so handle them
+        // on the source directly.
+        source.on('error', onError);
+        const batched = source.pipe((0, _nodebufferedtransformstream.createNodeBufferedTransformStream)(MAX_DEBUG_CHANNEL_BATCH_BYTES));
+        batched.on('data', sendChunk);
+        batched.on('end', stop);
+        batched.on('error', onError);
+    }
+}
+function connectReactDebugChannelForHtmlRequest(htmlRequestId, sendToClient) {
+    const debugChannel = reactDebugChannelsByHtmlRequestId.get(htmlRequestId);
+    if (!debugChannel) {
+        return;
+    }
+    reactDebugChannelsByHtmlRequestId.delete(htmlRequestId);
+    connectReactDebugChannel(htmlRequestId, debugChannel, sendToClient);
+}
+function setReactDebugChannelForHtmlRequest(htmlRequestId, debugChannel) {
+    // TODO: Clean up after a timeout, in case the client never connects, e.g.
+    // when CURL'ing the page, or loading the page with JavaScript disabled etc.
+    reactDebugChannelsByHtmlRequestId.set(htmlRequestId, debugChannel);
+}
+function deleteReactDebugChannelForHtmlRequest(htmlRequestId) {
+    reactDebugChannelsByHtmlRequestId.delete(htmlRequestId);
+}
+
+//# sourceMappingURL=debug-channel.js.map

package/dist/ray/node_modules/next/dist/server/dev/dev-indicator-server-state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "devIndicatorServerState", {
+    enumerable: true,
+    get: function() {
+        return devIndicatorServerState;
+    }
+});
+const devIndicatorServerState = {
+    disabledUntil: 0
+};
+
+//# sourceMappingURL=dev-indicator-server-state.js.map

package/dist/ray/node_modules/next/dist/server/dev/dev-validation-worker-pool.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    dropDevValidationWorker: null,
+    installDevValidationWorker: null,
+    mirrorModuleStateToDevValidationWorker: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    dropDevValidationWorker: function() {
+        return dropDevValidationWorker;
+    },
+    installDevValidationWorker: function() {
+        return installDevValidationWorker;
+    },
+    mirrorModuleStateToDevValidationWorker: function() {
+        return mirrorModuleStateToDevValidationWorker;
+    }
+});
+const _jestworker = require("next/dist/compiled/jest-worker");
+const _devvalidationworkerglobals = require("../app-render/dev-validation-worker-globals");
+const _requirecache = require("./require-cache");
+const _utils = require("../lib/utils");
+const _needsexperimentalreact = require("../../lib/needs-experimental-react");
+/**
+ * Replays a change the dev server made to its own module state in the
+ * validation worker. Installed alongside the worker, so it is absent when no
+ * worker runs (`experimental.devValidationWorker: false`, or Webpack).
+ */ let mirrorModuleState;
+/**
+ * Drops the validation worker. Called when the dev server cannot repair its own
+ * module state in place and re-evaluates every module from disk, which the
+ * worker matches by starting over: the next validation spawns a worker that
+ * loads the current build output.
+ *
+ * A worker dropped on its own, by a failed replay or a crash, is the one case
+ * where the two can diverge. The dev server keeps the modules it evaluated from
+ * earlier updates, and a worker spawned afterwards has no way to obtain those
+ * scripts, so frames naming them stay unresolved until those modules change
+ * again. The validation itself is unaffected, because the worker loads the
+ * current code from disk.
+ */ let dropWorker;
+function mirrorModuleStateToDevValidationWorker(change) {
+    mirrorModuleState == null ? void 0 : mirrorModuleState(change);
+}
+function dropDevValidationWorker() {
+    dropWorker == null ? void 0 : dropWorker();
+}
+function installDevValidationWorker(options) {
+    const { distDir, buildId, deploymentId, nextConfig } = options;
+    // A single worker, not a pool. Validation for one navigation runs its depth
+    // loop sequentially, and a newer navigation supersedes the previous one
+    // (aborting it mid-run) rather than running concurrently, so there's no
+    // per-request fan-out to parallelize (unlike the `'use cache'` probe, where
+    // one request fans out into concurrent probes). One worker already frees the
+    // main thread, which is the whole point; it also keeps each request's CLI
+    // marker block contiguous in the piped output. Torn down on HMR (stale user
+    // modules) and on crash.
+    //
+    // TODO(dev-validation-worker): raise `numWorkers` if concurrent navigations
+    // across independent requests (e.g. multiple tabs) show a validation-latency
+    // tail. Raising it means `mirrorChange` has to reach every worker instead of
+    // whichever one the pool hands the call to, and the ordering it relies on
+    // holds per worker rather than across them.
+    let pool;
+    const mirrorChange = (change)=>{
+        const current = pool;
+        if (!current) {
+            // No worker to keep current, and nothing to replay into a later one: the
+            // compilation that produced this change also wrote the updated chunk to
+            // disk, so a worker spawning after it reads the current code through
+            // `loadComponents`. Evaluating the update is what an isolate that is
+            // already running needs, not what a new one does.
+            return;
+        }
+        // The worker runs one call at a time, in the order the calls were made
+        // (see `numWorkers` below), so this is replayed before any validation
+        // requested after it, and never in the middle of one. That ordering is by
+        // call time, which is why the call is made here, as the change arrives,
+        // rather than deferred onto a queue of our own. A validation already
+        // queued runs first, which is what its render needs: it was produced
+        // before this change. The dev server does not hold its own updates back
+        // for a validation running in process either.
+        const replayed = change.type === 'invalidate' ? current.invalidateCaches(change.filePaths, change.evictModules) : current.applyHmrUpdate(change.update).then(async (outcome)=>{
+            if (outcome === 'failed') {
+                await tearDownPool();
+            }
+        });
+        void replayed.catch(async ()=>{
+            // A replay that failed leaves the worker's state unknown, so it is
+            // dropped rather than trusted.
+            await tearDownPool();
+        });
+    };
+    const getPool = ()=>{
+        if (pool) {
+            return pool;
+        }
+        // Strip `--inspect` from any inherited `NODE_OPTIONS` so the worker doesn't
+        // fight the parent for the same debug port.
+        const workerNodeOptions = (0, _utils.getFormattedNodeOptionsWithoutInspect)();
+        // The worker is shipped as four pre-bundled dev-only artifacts
+        // ({webpack,turbopack} × {stable,experimental}), one per combination of the
+        // user's bundler and vendored React channel. Pick the matching artifact
+        // from runtime env so the worker stays in lockstep with the user's app
+        // bundle. `needsExperimentalReact` is the same predicate `define-env.ts`
+        // uses to wire `__NEXT_EXPERIMENTAL_REACT`.
+        const turbo = process.env.TURBOPACK ? '-turbo' : '';
+        const channel = (0, _needsexperimentalreact.needsExperimentalReact)(nextConfig) ? '-experimental' : '';
+        const workerPath = require.resolve(`next/dist/compiled/next-server/dev-validation-worker${turbo}${channel}.runtime.dev.js`);
+        const worker = new _jestworker.Worker(workerPath, {
+            maxRetries: 0,
+            numWorkers: 1,
+            // Always worker-threads, regardless of `experimental.workerThreads`.
+            // Unlike the `'use cache'` probe (which follows the flag), validation has
+            // no reason to prefer a child process: it doesn't need process-level
+            // isolation (a worker thread already has its own V8 heap and module
+            // registry, so the reloaded route is isolated from the main thread), and
+            // threads let a superseded validation be aborted mid-run through a shared
+            // `SharedArrayBuffer`, which a separate process can't receive. Threads
+            // also carry the transported Flight bytes as typed arrays via structured
+            // clone, with no JSON round-trip to corrupt them.
+            enableWorkerThreads: true,
+            // Listing the method explicitly tells jest-worker to skip the discovery
+            // `require()` it would otherwise do in the parent process to enumerate
+            // the module's exports. This worker's top-level imports (`require-hook`,
+            // `node-environment`) run runtime setup meant only for the isolated
+            // worker thread, so they must not be evaluated in the parent.
+            exposedMethods: [
+                'runDevValidation',
+                'applyHmrUpdate',
+                'invalidateCaches'
+            ],
+            forkOptions: {
+                env: {
+                    ...process.env,
+                    NODE_OPTIONS: workerNodeOptions
+                }
+            }
+        });
+        worker.getStdout().pipe(process.stdout);
+        worker.getStderr().pipe(process.stderr);
+        pool = worker;
+        return worker;
+    };
+    const tearDownPool = async ()=>{
+        const current = pool;
+        if (!current) {
+            return;
+        }
+        pool = undefined;
+        await current.end().catch(()=>{
+        // The worker thread exits on its own once its work settles; a failed
+        // `.end()` here just means we couldn't wait for it cleanly.
+        });
+    };
+    const runValidation = async (snapshot, validationAbortSignal)=>{
+        let activePool;
+        try {
+            activePool = getPool();
+        } catch  {
+            return null;
+        }
+        const message = {
+            ...snapshot,
+            distDir,
+            buildId,
+            deploymentId,
+            nextConfigSerializable: {
+                httpAgentOptions: nextConfig.httpAgentOptions,
+                cacheLifeProfiles: nextConfig.cacheLife,
+                useCacheTimeout: nextConfig.experimental.useCacheTimeout,
+                staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout
+            }
+        };
+        // The worker runs as a thread (see `enableWorkerThreads` above), so an
+        // abort reaches it through a one-slot shared flag rather than the abort
+        // signal directly (a signal can't cross the thread boundary). Mirror an
+        // abort of `validationAbortSignal` into the buffer and wake the worker's
+        // `Atomics.waitAsync` on it, so it aborts the in-flight run at its next
+        // depth boundary.
+        const abortBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+        const abortFlag = new Int32Array(abortBuffer);
+        const propagateAbort = ()=>{
+            Atomics.store(abortFlag, 0, 1);
+            Atomics.notify(abortFlag, 0);
+        };
+        if (validationAbortSignal.aborted) {
+            propagateAbort();
+        } else {
+            validationAbortSignal.addEventListener('abort', propagateAbort, {
+                once: true
+            });
+        }
+        try {
+            return await activePool.runDevValidation(message, abortBuffer);
+        } catch  {
+            // Worker crash or IPC error: tear down so the next validation starts
+            // fresh. The main thread treats a missing result as "nothing to deliver."
+            await tearDownPool();
+            return null;
+        } finally{
+            // `once` only auto-removes the listener if it fired, so remove it
+            // explicitly to bound its lifetime to this run when validation completed
+            // without being superseded.
+            validationAbortSignal.removeEventListener('abort', propagateAbort);
+        }
+    };
+    // The dev server just cleared these paths from its own `require.cache` and
+    // manifest caches. The worker clears them from its copies.
+    (0, _requirecache.onCacheInvalidation)((filePaths)=>{
+        mirrorChange({
+            type: 'invalidate',
+            filePaths,
+            evictModules: true
+        });
+    });
+    mirrorModuleState = mirrorChange;
+    dropWorker = ()=>{
+        void tearDownPool();
+    };
+    (0, _devvalidationworkerglobals.setDevValidationWorker)(runValidation);
+}
+
+//# sourceMappingURL=dev-validation-worker-pool.js.map