@evoscientist/webui 0.2.4 → 0.2.6

package/dist/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

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

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    applyHmrUpdate: null,
+    invalidateCaches: null,
+    runDevValidation: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    applyHmrUpdate: function() {
+        return applyHmrUpdate;
+    },
+    invalidateCaches: function() {
+        return invalidateCaches;
+    },
+    runDevValidation: function() {
+        return runDevValidation;
+    }
+});
+require("../require-hook");
+require("../node-environment");
+const _path = require("path");
+const _fs = require("fs");
+const _url = require("url");
+const _installbindings = require("../../build/swc/install-bindings");
+const _installcodeframe = require("../lib/install-code-frame");
+const _loadcomponents = require("../load-components");
+const _setuphttpagentenv = require("../setup-http-agent-env");
+const _devvalidationerrordelivery = require("../app-render/dev-validation-error-delivery");
+const _devvalidationevents = require("../app-render/dev-validation-events");
+const _loadmanifestexternal = require("../load-manifest.external");
+const _requirecache = require("./require-cache");
+const _manifestssingleton = require("../app-render/manifests-singleton");
+const _patcherrorinspect = require("../patch-error-inspect");
+/**
+ * Resolves a chunk's source map by reading the `.map` file the bundler emitted
+ * next to it, for chunks inside `distDir`.
+ *
+ * The main thread answers the same question through the Turbopack project
+ * handle, which cannot cross a thread boundary. Reading from disk is
+ * project-free and, more importantly, does not depend on the chunk having been
+ * evaluated in this thread: Node.js caches source maps per isolate, and the
+ * worker never renders server components, so it holds maps only for the chunks
+ * `loadComponents` pulled in. Frames arriving in the transported payload can
+ * point at any chunk the main render touched.
+ *
+ * Reading from disk covers the chunks, because the worker only runs under
+ * Turbopack (see `next-dev-server.ts`), which writes a `.map` beside every one
+ * of them. A module the server updated in place has no chunk of its own and is
+ * covered instead by this thread applying the same update (see
+ * `applyHmrUpdate`), which leaves its inline map in Node.js' cache here. Frames
+ * from dependencies that are not bundled never reach this point, because
+ * `filterStackFrameDEV` drops `node_modules` and `node:` frames; bundled
+ * dependencies appear as chunks inside `distDir` like any other code.
+ */ function createDiskSourceMapLookup(distDir) {
+    // The frames carry resolved paths, so compare against the resolved `distDir`
+    // to keep the containment check meaningful when the project sits behind a
+    // symlink.
+    let canonicalDistDir = distDir;
+    try {
+        canonicalDistDir = (0, _fs.realpathSync)(distDir);
+    } catch  {}
+    const payloads = new Map();
+    return function findSourceMapPayloadOnDisk(sourceURL) {
+        let chunkPath = sourceURL;
+        if (chunkPath.startsWith('file://')) {
+            try {
+                chunkPath = (0, _url.fileURLToPath)(chunkPath);
+            } catch  {
+                return undefined;
+            }
+        }
+        if (!(0, _path.isAbsolute)(chunkPath)) {
+            // Not an emitted chunk, e.g. `<anonymous>`.
+            return undefined;
+        }
+        const cached = payloads.get(chunkPath);
+        if (cached !== undefined || payloads.has(chunkPath)) {
+            return cached;
+        }
+        let payload;
+        const relativePath = (0, _path.relative)(canonicalDistDir, chunkPath);
+        // Only chunks emitted into `distDir` have a source map to point at, and
+        // this keeps the lookup from reading arbitrary paths off disk.
+        if (!relativePath.startsWith('..') && !(0, _path.isAbsolute)(relativePath)) {
+            try {
+                payload = JSON.parse((0, _fs.readFileSync)(chunkPath + '.map', 'utf8'));
+            } catch  {
+                payload = undefined;
+            }
+        }
+        payloads.set(chunkPath, payload);
+        return payload;
+    };
+}
+// Match the main dev server (`next-dev-server.ts`), which raises this so the
+// server captures deeper stacks. React's owner-stack capture during the
+// validation prerenders depends on it, so without it the worker's errors lose
+// their owner-stack source attribution.
+try {
+    Error.stackTraceLimit = 50;
+} catch  {}
+// The lifecycle markers E2E tests read from the CLI. Emitted on the worker's
+// stdout (piped to the parent) so they interleave with the parent's captured
+// output the same way the in-process `runWithDevValidationLogging` markers do.
+// Gated on the same test env that path checks.
+const isTestLoggingEnabled = !!(process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION);
+/**
+ * Adapts the pool's supersede flag into an `AbortSignal` the validation passes
+ * check at their depth/yield boundaries. The pool shares an `Int32Array`-backed
+ * `SharedArrayBuffer` whose first slot the main thread flips to non-zero (with
+ * `Atomics.store` + `Atomics.notify`) when a newer navigation supersedes this
+ * one. We wait for that notification with `Atomics.waitAsync`, which is
+ * event-driven rather than polled. A validation that finishes without being
+ * superseded calls `cleanup()`, which wakes our own still-pending wait so it
+ * leaves no waiter (and no retained buffer) behind.
+ */ function createSupersedeSignal(abortBuffer) {
+    const controller = new AbortController();
+    const flag = new Int32Array(abortBuffer);
+    if (Atomics.load(flag, 0) !== 0) {
+        controller.abort();
+        return {
+            signal: controller.signal,
+            cleanup: ()=>{}
+        };
+    }
+    let settled = false;
+    const wait = Atomics.waitAsync(flag, 0, 0);
+    if (wait.async) {
+        wait.value.then(()=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            // Woken either by a real supersede or by `cleanup()`; only the former
+            // leaves the flag set.
+            if (Atomics.load(flag, 0) !== 0) {
+                controller.abort();
+            }
+        });
+    } else if (Atomics.load(flag, 0) !== 0) {
+        // The flag flipped between the load above and the wait.
+        controller.abort();
+    }
+    return {
+        signal: controller.signal,
+        cleanup: ()=>{
+            if (!settled) {
+                Atomics.notify(flag, 0);
+            }
+        }
+    };
+}
+/**
+ * Waits out the test-only validation delay, resolving early if the render is
+ * superseded. Mirrors the delay in `runWithDevValidationLogging` so scheduler
+ * tests observe the same in-flight window on the worker path.
+ */ async function applyTestValidationDelay(signal) {
+    const delayMs = Number(process.env.NEXT_TEST_DEV_VALIDATION_DELAY_MS);
+    if (!Number.isFinite(delayMs) || delayMs <= 0 || signal.aborted) {
+        return;
+    }
+    await new Promise((resolve)=>{
+        const finishDelay = ()=>{
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', finishDelay);
+            resolve();
+        };
+        const timeout = setTimeout(finishDelay, delayMs);
+        signal.addEventListener('abort', finishDelay, {
+            once: true
+        });
+    });
+}
+/**
+ * Registers the client reference manifests of the pages that supplied client
+ * references to the render being validated, beyond the validated route's own
+ * manifest. This thread has its own manifests singleton, which `loadComponents`
+ * seeds with only the validated route, so without these the dev-only cross-page
+ * lookup in `createProxiedClientReferenceManifest` has no other manifest to
+ * search and decoding the transported payload fails. Usually a no-op, since the
+ * main thread only records a page when React's I/O tracking actually carried a
+ * reference across pages.
+ */ async function registerAdditionalClientReferenceManifests(distDir, pages) {
+    if (pages.length === 0) {
+        return;
+    }
+    // Set by `loadComponents`. One server actions manifest covers the whole app,
+    // so the pages registered here share the validated route's.
+    const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
+    await Promise.all(pages.map(async (page)=>{
+        const clientReferenceManifest = await (0, _loadcomponents.loadClientReferenceManifestForPage)(distDir, page);
+        if (clientReferenceManifest) {
+            (0, _manifestssingleton.setManifestsSingleton)({
+                page,
+                clientReferenceManifest,
+                serverActionsManifest
+            });
+        }
+    }));
+}
+async function applyHmrUpdate(update) {
+    if (typeof __turbopack_server_hmr_apply__ !== 'function') {
+        return 'no-runtime';
+    }
+    try {
+        __turbopack_server_hmr_apply__(update);
+    } catch  {
+        // The dev server responds to the same failure by re-evaluating every
+        // module from disk. This thread cannot be repaired in place either, so the
+        // caller drops it.
+        return 'failed';
+    }
+    return 'applied';
+}
+async function invalidateCaches(filePaths, evictModules) {
+    if (evictModules) {
+        (0, _requirecache.deleteCache)(filePaths);
+        return;
+    }
+    for (const filePath of filePaths){
+        (0, _loadmanifestexternal.clearManifestCache)(filePath);
+    }
+}
+async function runDevValidation(message, abortBuffer) {
+    // Load the native SWC bindings and wire the code-frame renderer so the errors
+    // logged below render with a source-mapped code frame, matching the
+    // in-process dev output (the E2E tests snapshot the CLI text between the
+    // validation markers). The `build/swc` graph these pull in is bundled as a
+    // runtime external (see `next-runtime.webpack-config.js`), so it resolves
+    // from the installed `next/dist` tree rather than being compiled into this
+    // worker bundle, the same way the unbundled build worker loads it.
+    await (0, _installbindings.installBindings)();
+    (0, _installcodeframe.installCodeFrameSupport)();
+    (0, _patcherrorinspect.setBundlerFindSourceMapImplementation)(createDiskSourceMapLookup(message.distDir));
+    (0, _setuphttpagentenv.setHttpClientAndAgentOptions)({
+        httpAgentOptions: message.nextConfigSerializable.httpAgentOptions
+    });
+    // Populates the manifests singleton for the route via `setManifestsSingleton`
+    // inside `loadComponents`, exactly as a real request does. The pool tears the
+    // worker down on HMR / route recompile so the next validation reloads from a
+    // clean require cache.
+    const { ComponentMod } = await (0, _loadcomponents.loadComponents)({
+        distDir: message.distDir,
+        page: message.page,
+        isAppPath: true,
+        isDev: true,
+        sriEnabled: false,
+        needsManifestsForLegacyReasons: true
+    });
+    await registerAdditionalClientReferenceManifests(message.distDir, message.additionalClientReferenceManifestPages);
+    const { signal, cleanup } = createSupersedeSignal(abortBuffer);
+    if (isTestLoggingEnabled) {
+        console.log((0, _devvalidationevents.formatValidationEvent)({
+            type: 'validation_start',
+            requestId: message.requestId,
+            url: message.request.urlPathname + message.request.urlSearch,
+            responseFinished: message.responseFinished
+        }));
+    }
+    try {
+        if (isTestLoggingEnabled) {
+            await applyTestValidationDelay(signal);
+        }
+        if (signal.aborted) {
+            return null;
+        }
+        // Crossing into the app-page bundle: the entire validation runs there, so
+        // the client prerenders use the same React the user's client components
+        // resolve through `ComponentMod`.
+        const validationErrors = await ComponentMod.routeModule.runValidationInDev(ComponentMod, message, signal);
+        if (validationErrors === undefined || signal.aborted) {
+            return null;
+        }
+        const errors = [];
+        for (const validationError of validationErrors){
+            // Log to the worker's stderr; `node-environment` +
+            // `installCodeFrameSupport` render the source-mapped stack and code frame
+            // there, matching the in-process CLI output.
+            console.error(validationError);
+            if (validationError instanceof Error) {
+                errors.push(validationError);
+            }
+        }
+        if (errors.length === 0) {
+            return null;
+        }
+        return await (0, _devvalidationerrordelivery.serializeValidationErrorsToFlight)(ComponentMod, errors);
+    } finally{
+        cleanup();
+        if (isTestLoggingEnabled) {
+            console.log((0, _devvalidationevents.formatValidationEvent)({
+                type: signal.aborted ? 'validation_aborted' : 'validation_end',
+                requestId: message.requestId,
+                url: message.request.urlPathname + message.request.urlSearch
+            }));
+        }
+    }
+}
+
+//# sourceMappingURL=dev-validation-worker.js.map

package/dist/node_modules/next/dist/server/dev/hot-middleware.js

@@ -31,6 +31,7 @@ const _utils = require("../../build/utils");
 const _hotreloadertypes = require("./hot-reloader-types");
 const _devindicatorserverstate = require("./dev-indicator-server-state");
 const _messages = require("./messages");
+const _requestinsights = require("../lib/trace/request-insights");
 function isMiddlewareStats(stats) {
     for (const key of stats.compilation.entrypoints.keys()){
         if ((0, _utils.isMiddlewareFilename)(key)) {
@@ -171,7 +172,8 @@ class WebpackHotMiddleware {
                         devtoolsFrontendUrl: this.devtoolsFrontendUrl
                     },
                     devIndicator: _devindicatorserverstate.devIndicatorServerState,
-                    devToolsConfig: this.devToolsConfig
+                    devToolsConfig: this.devToolsConfig,
+                    requestInsights: this.config.experimental.requestInsights || (0, _requestinsights.isRequestInsightsEnabled)() ? (0, _requestinsights.getRequestInsightsSnapshot)() : undefined
                 });
             }
         };

package/dist/node_modules/next/dist/server/dev/hot-reloader-rspack.js

@@ -125,7 +125,7 @@ class HotReloaderRspack extends _hotreloaderwebpack.default {
             if (key === 'server' && !this.isServerCacheEnabled) return;
             if (key === 'edge-server' && !this.isEdgeServerCacheEnabled) return;
             // TODO: Rspack does not store middleware entries in persistent cache, causing
-            // test/integration/middleware-src/test/index.test.ts to fail. This is a temporary
+            // test/e2e/middleware-src/middleware-src.test.ts to fail. This is a temporary
             // workaround to skip middleware entry caching until Rspack properly supports it.
             if (page === '/middleware') {
                 return;