@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/app-render/make-get-server-inserted-html.js

@@ -13,10 +13,9 @@ const _react = /*#__PURE__*/ _interop_require_default(require("react"));
 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 _server = require("react-dom/server");
-const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
 const _redirectstatuscode = require("../../client/components/redirect-status-code");
 const _addpathprefix = require("../../shared/lib/router/utils/add-path-prefix");
+const _streamops = require("./stream-ops");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -67,7 +66,7 @@ function makeGetServerInsertedHTML({ polyfills, renderServerInsertedHTML, server
         if (polyfillTags.length === 0 && traceMetaTags.length === 0 && errorMetaTags.length === 0 && Array.isArray(serverInsertedHTML) && serverInsertedHTML.length === 0) {
             return '';
         }
-        const stream = await (0, _server.renderToReadableStream)(/*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+        const { stream } = await (process.env.__NEXT_USE_NODE_STREAMS ? _streamops.renderToNodeFizzStream : _streamops.renderToWebFizzStream)(/*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
             children: [
                 polyfillTags,
                 serverInsertedHTML,
@@ -85,7 +84,7 @@ function makeGetServerInsertedHTML({ polyfills, renderServerInsertedHTML, server
         // There's no need to wait for the stream to be ready
         // e.g. calling `await stream.allReady` because `streamToString` will
         // wait and decode the stream progressively with better parallelism.
-        return (0, _nodewebstreamshelper.streamToString)(stream);
+        return (0, _streamops.streamToString)(stream);
     };
 }
 

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

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    getActionNotFoundError: null,
     getClientReferenceManifest: null,
+    getInvalidServerReferenceIdError: null,
     getServerActionsManifest: null,
     getServerModuleMap: null,
     selectWorkerForForwarding: null,
@@ -16,9 +18,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    getActionNotFoundError: function() {
+        return getActionNotFoundError;
+    },
     getClientReferenceManifest: function() {
         return getClientReferenceManifest;
     },
+    getInvalidServerReferenceIdError: function() {
+        return getInvalidServerReferenceIdError;
+    },
     getServerActionsManifest: function() {
         return getServerActionsManifest;
     },
@@ -36,7 +44,36 @@ const _invarianterror = require("../../shared/lib/invariant-error");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
 const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
+const _serverreferenceinfo = require("../../shared/lib/server-reference-info");
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _workasyncstorageexternal = require("./work-async-storage.external");
+function getActionNotFoundError(actionId) {
+    return Object.defineProperty(new Error(`Failed to find Server Action${actionId ? ` "${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: "E974",
+        enumerable: false,
+        configurable: true
+    });
+}
+function getInvalidServerReferenceIdError(id) {
+    // `id` is arbitrary client-provided input. Unlike the not-found case, it has
+    // not passed the length gate and can reach this error via a malformed server
+    // reference in an action payload, so it may be of any length and contain
+    // control characters. `JSON.stringify` escapes newlines and quotes so it
+    // can't forge log lines, and truncating overly long ids prevents log
+    // flooding. Ids at or below the cap are logged in full so that we only add an
+    // ellipsis to ids that are meaningfully longer than the truncated length.
+    const encoded = JSON.stringify(id.length > MAX_LOGGED_SERVER_REFERENCE_ID_LENGTH ? id.slice(0, TRUNCATED_SERVER_REFERENCE_ID_LENGTH) + '…' : id);
+    return Object.defineProperty(new Error(`The Server Reference ID did not match the expected format. Received ${encoded}.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
+        value: "E1442",
+        enumerable: false,
+        configurable: true
+    });
+}
+// Ids at or below the cap are logged in full. Longer ids are truncated to the
+// shorter length and marked with an ellipsis, so the cap leaves headroom over
+// the truncated length rather than ellipsizing ids that are barely too long.
+const MAX_LOGGED_SERVER_REFERENCE_ID_LENGTH = 100;
+const TRUNCATED_SERVER_REFERENCE_ID_LENGTH = 90;
 // This is a global singleton that is, among other things, also used to
 // encode/decode bound args of server function closures. This can't be using a
 // AsyncLocalStorage as it might happen at the module level.
@@ -48,7 +85,8 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
             get (_, id) {
                 const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
                 if (workStore) {
-                    const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
+                    var _clientReferenceManifestsPerRoute_get;
+                    const currentManifest = (_clientReferenceManifestsPerRoute_get = clientReferenceManifestsPerRoute.get(workStore.route)) == null ? void 0 : _clientReferenceManifestsPerRoute_get.clientReferenceManifest;
                     if (currentManifest == null ? void 0 : currentManifest[prop][id]) {
                         return currentManifest[prop][id];
                     }
@@ -63,12 +101,19 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                     // client references across pages (e.g. by storing them in a global
                     // variable), which would then only be caught in production.
                     if (process.env.NODE_ENV !== 'production') {
-                        for (const [route, manifest] of clientReferenceManifestsPerRoute){
+                        for (const [route, { page, clientReferenceManifest }] of clientReferenceManifestsPerRoute){
                             if (route === workStore.route) {
                                 continue;
                             }
-                            const entry = manifest[prop][id];
+                            const entry = clientReferenceManifest[prop][id];
                             if (entry !== undefined) {
+                                if (process.env.__NEXT_DEV_SERVER) {
+                                    // The dev validation worker rebuilds this registry in its
+                                    // own thread, seeded with only the route it validates, so
+                                    // it has to be told which other manifests it needs.
+                                    workStore.additionalClientReferenceManifestPages ??= new Set();
+                                    workStore.additionalClientReferenceManifestPages.add(page);
+                                }
                                 return entry;
                             }
                         }
@@ -80,8 +125,8 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                     // might also use client components which need to be serialized by
                     // Flight, and therefore client references need to be resolvable. In
                     // that case we search all page manifests to find the module.
-                    for (const manifest of clientReferenceManifestsPerRoute.values()){
-                        const entry = manifest[prop][id];
+                    for (const { clientReferenceManifest } of clientReferenceManifestsPerRoute.values()){
+                        const entry = clientReferenceManifest[prop][id];
                         if (entry !== undefined) {
                             return entry;
                         }
@@ -107,15 +152,15 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                                 configurable: true
                             });
                         }
-                        const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
-                        if (!currentManifest) {
+                        const registeredManifest = clientReferenceManifestsPerRoute.get(workStore.route);
+                        if (!registeredManifest) {
                             throw Object.defineProperty(new _invarianterror.InvariantError(`The client reference manifest for route "${workStore.route}" does not exist.`), "__NEXT_ERROR_CODE", {
                                 value: "E951",
                                 enumerable: false,
                                 configurable: true
                             });
                         }
-                        return currentManifest[prop];
+                        return registeredManifest.clientReferenceManifest[prop];
                     }
                 case 'clientModules':
                 case 'rscModuleMapping':
@@ -148,12 +193,23 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
  * our manifest contains a lot of internal Next.js data that are relevant to the
  * runtime, workers, etc. that React doesn't need to know.
  */ function createServerModuleMap() {
-    return new Proxy({}, {
-        get: (_, id)=>{
+    return new Proxy(Object.create(null), {
+        get: (target, id, receiver)=>{
             var _getServerActionsManifest__id, _getServerActionsManifest_;
+            // React's debug serialization can probe the module map like a plain object.
+            // These probes are not server reference lookups.
+            if (typeof id !== 'string') {
+                return Reflect.get(target, id, receiver);
+            }
+            if (_reflectutils.wellKnownProperties.has(id)) {
+                return Reflect.get(target, id, receiver);
+            }
+            if (!(0, _serverreferenceinfo.mightBeServerReferenceId)(id)) {
+                throw getInvalidServerReferenceIdError(id);
+            }
             const workers = (_getServerActionsManifest_ = getServerActionsManifest()[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_getServerActionsManifest__id = _getServerActionsManifest_[id]) == null ? void 0 : _getServerActionsManifest__id.workers;
             if (!workers) {
-                return undefined;
+                throw getActionNotFoundError(id);
             }
             const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
             let workerEntry;
@@ -170,7 +226,7 @@ function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute)
                 workerEntry = Object.values(workers).at(0);
             }
             if (!workerEntry) {
-                return undefined;
+                throw getActionNotFoundError(id);
             }
             const { moduleId, async } = workerEntry;
             return {
@@ -214,6 +270,7 @@ function selectWorkerForForwarding(actionId, pageName) {
 }
 function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest: rawServerActionsManifest }) {
     const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
+    const route = (0, _apppaths.normalizeAppPath)(page);
     const serverActionsManifest = {
         encryptionKey: rawServerActionsManifest.encryptionKey,
         // Use null-prototypes for the action objects to prevent prototype pollution
@@ -222,13 +279,19 @@ function setManifestsSingleton({ page, clientReferenceManifest, serverActionsMan
         edge: Object.assign(Object.create(null), rawServerActionsManifest.edge)
     };
     if (existingSingleton) {
-        existingSingleton.clientReferenceManifestsPerRoute.set((0, _apppaths.normalizeAppPath)(page), clientReferenceManifest);
+        existingSingleton.clientReferenceManifestsPerRoute.set(route, {
+            page,
+            clientReferenceManifest
+        });
         existingSingleton.serverActionsManifest = serverActionsManifest;
     } else {
         const clientReferenceManifestsPerRoute = new Map([
             [
-                (0, _apppaths.normalizeAppPath)(page),
-                clientReferenceManifest
+                route,
+                {
+                    page,
+                    clientReferenceManifest
+                }
             ]
         ]);
         const proxiedClientReferenceManifest = createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute);

package/dist/node_modules/next/dist/server/app-render/module-loading/instrument-module-getter.js

@@ -0,0 +1,32 @@
+/**
+ * Wraps a module getter from the generated loader tree code so that the
+ * result of an async module (e.g. due to a top-level await) is tracked as a
+ * pending import, which the cache warming phase of a prerender waits for.
+ * Both bundlers emit this around every module getter in the loader tree.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "instrumentModuleGetter", {
+    enumerable: true,
+    get: function() {
+        return instrumentModuleGetter;
+    }
+});
+function instrumentModuleGetter(getter) {
+    if (process.env.NEXT_RUNTIME === 'edge' || !process.env.__NEXT_CACHE_COMPONENTS) {
+        // The tracking is only consumed when prerendering with Cache Components,
+        // which is not supported in the edge runtime (and the tracking relies on
+        // Node.js APIs).
+        return getter;
+    } else {
+        return ()=>{
+            const { trackPendingImport } = require('./track-module-loading.external');
+            const exportsOrPromise = getter();
+            trackPendingImport(exportsOrPromise);
+            return exportsOrPromise;
+        };
+    }
+}
+
+//# sourceMappingURL=instrument-module-getter.js.map

package/dist/node_modules/next/dist/server/app-render/module-loading/track-module-loading.instance.js

@@ -25,7 +25,6 @@ _export(exports, {
     }
 });
 const _cachesignal = require("../cache-signal");
-const _isthenable = require("../../../shared/lib/is-thenable");
 /**
  * Tracks all in-flight async imports and chunk loads.
  * Initialized lazily, because we don't want this to error in case it gets pulled into an edge runtime module.
@@ -44,11 +43,8 @@ function trackPendingImport(exportsOrPromise) {
     const moduleLoadingSignal = getModuleLoadingSignal();
     // requiring an async module returns a promise.
     // if it's sync, there's nothing to track.
-    if ((0, _isthenable.isThenable)(exportsOrPromise)) {
-        // A client reference proxy might look like a promise, but we can only call `.then()` on it, not e.g. `.finally()`.
-        // Turn it into a real promise to avoid issues elsewhere.
-        const promise = Promise.resolve(exportsOrPromise);
-        moduleLoadingSignal.trackRead(promise);
+    if (exportsOrPromise instanceof Promise) {
+        moduleLoadingSignal.trackRead(exportsOrPromise);
     }
 }
 function trackPendingModules(cacheSignal) {

package/dist/node_modules/next/dist/server/app-render/postponed-state.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
     getDynamicDataPostponedState: null,
     getDynamicHTMLPostponedState: null,
     getPostponedFromState: null,
+    isEmptyHTMLPrelude: null,
     parsePostponedState: null
 });
 function _export(target, all) {
@@ -32,6 +33,9 @@ _export(exports, {
     getPostponedFromState: function() {
         return getPostponedFromState;
     },
+    isEmptyHTMLPrelude: function() {
+        return isEmptyHTMLPrelude;
+    },
     parsePostponedState: function() {
         return parsePostponedState;
     }
@@ -79,8 +83,10 @@ function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeByt
         var _state_match;
         const postponedStringLengthMatch = (_state_match = state.match(/^([0-9]*):/)) == null ? void 0 : _state_match[1];
         if (!postponedStringLengthMatch) {
-            throw Object.defineProperty(new Error(`Invariant: invalid postponed state ${state}`), "__NEXT_ERROR_CODE", {
-                value: "E314",
+            // Do not include the raw state in the message: it can be large and may
+            // contain sensitive serialized data.
+            throw Object.defineProperty(new Error('Invariant: invalid postponed state: missing length prefix'), "__NEXT_ERROR_CODE", {
+                value: "E1388",
                 enumerable: false,
                 configurable: true
             });
@@ -132,20 +138,57 @@ function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeByt
                 renderResumeDataCache
             };
         } catch (err) {
-            console.error('Failed to parse postponed state', err);
+            console.error('Failed to parse postponed state', describePostponedStateParseFailure(state, err));
             return {
                 type: 1,
                 renderResumeDataCache
             };
         }
     } catch (err) {
-        console.error('Failed to parse postponed state', err);
+        console.error('Failed to parse postponed state', describePostponedStateParseFailure(state, err));
         return {
             type: 1,
-            renderResumeDataCache: (0, _resumedatacache.createPrerenderResumeDataCache)()
+            renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)((0, _resumedatacache.createPrerenderResumeDataCache)())
         };
     }
 }
+/**
+ * Derives content-free diagnostics about a postponed state that failed to
+ * parse, so the error log is actionable without exposing the (potentially
+ * sensitive) serialized contents. Every field is a size, a structural flag, or
+ * an error code, never the state bytes themselves.
+ *
+ * The serialized layout is `<N>:<postponedString><base64-deflate cache>`, so
+ * these fields distinguish the failure shapes:
+ * - `postponedStringComplete: false`: the declared length `N` exceeds what
+ * actually arrived, i.e. the postponed string itself was truncated.
+ * - `errorCode: 'Z_BUF_ERROR'` with an empty or short tail: the
+ * resume-data-cache tail was truncated (ran out of input while inflating).
+ * - `errorCode: 'Z_DATA_ERROR'`: the tail bytes are corrupt, not merely short.
+ * - `hasLengthPrefix: false`: the body had no `<N>:` prefix at all (e.g. empty
+ * or otherwise malformed input).
+ */ function describePostponedStateParseFailure(state, error) {
+    const errnoError = error;
+    const diagnostics = {
+        stateLength: state.length,
+        errorName: error instanceof Error ? error.name : typeof error,
+        errorCode: errnoError == null ? void 0 : errnoError.code
+    };
+    const prefixMatch = state.match(/^([0-9]+):/);
+    if (!prefixMatch) {
+        diagnostics.hasLengthPrefix = false;
+        return diagnostics;
+    }
+    const declaredPostponedLength = parseInt(prefixMatch[1], 10);
+    const tailStart = prefixMatch[0].length + declaredPostponedLength;
+    const tail = state.slice(tailStart);
+    diagnostics.hasLengthPrefix = true;
+    diagnostics.declaredPostponedLength = declaredPostponedLength;
+    diagnostics.postponedStringComplete = state.length >= tailStart;
+    diagnostics.resumeDataCacheTailLength = tail.length;
+    diagnostics.resumeDataCacheTailIsNull = tail === 'null';
+    return diagnostics;
+}
 function getPostponedFromState(state) {
     const [preludeState, postponed] = state.data;
     return {
@@ -153,5 +196,35 @@ function getPostponedFromState(state) {
         postponed
     };
 }
+function isEmptyHTMLPrelude(state) {
+    try {
+        var _state_match;
+        const lengthMatch = (_state_match = state.match(/^([0-9]*):/)) == null ? void 0 : _state_match[1];
+        if (!lengthMatch) {
+            return false;
+        }
+        const length = parseInt(lengthMatch);
+        let postponedString = state.slice(lengthMatch.length + 1, lengthMatch.length + 1 + length);
+        // `null` is the dynamic-data case (a full shell was produced).
+        if (postponedString === 'null') {
+            return false;
+        }
+        // An optional `<n><replacements>` prefix carries fallback route param
+        // replacements; skip it to reach the `[preludeState, postponed]` data.
+        if (/^[0-9]/.test(postponedString)) {
+            var _postponedString_match;
+            const replacementsLengthMatch = (_postponedString_match = postponedString.match(/^([0-9]*)/)) == null ? void 0 : _postponedString_match[1];
+            if (!replacementsLengthMatch) {
+                return false;
+            }
+            const replacementsLength = parseInt(replacementsLengthMatch);
+            postponedString = postponedString.slice(replacementsLengthMatch.length + replacementsLength);
+        }
+        const data = JSON.parse(postponedString);
+        return Array.isArray(data) && data[0] === 0;
+    } catch  {
+        return false;
+    }
+}
 
 //# sourceMappingURL=postponed-state.js.map

package/dist/node_modules/next/dist/server/app-render/render-css-resource.js

@@ -12,7 +12,9 @@ const _encodeuripath = require("../../shared/lib/encode-uri-path");
 const _getassetquerystring = require("./get-asset-query-string");
 function renderCssResource(entryCssFiles, ctx, preloadCallbacks) {
     const { componentMod: { createElement } } = ctx;
-    return entryCssFiles.map((entryCssFile, index)=>{
+    const elements = [];
+    let index = 0;
+    for (const entryCssFile of entryCssFiles){
         // `Precedence` is an opt-in signal for React to handle resource
         // loading and deduplication, etc. It's also used as the key to sort
         // resources so they will be injected in the correct order.
@@ -28,25 +30,28 @@ function renderCssResource(entryCssFiles, ctx, preloadCallbacks) {
         // increasing.
         const fullHref = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(entryCssFile.path)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
         if (entryCssFile.inlined && !ctx.parsedRequestHeaders.isRSCRequest) {
-            return createElement('style', {
+            elements.push(createElement('style', {
                 key: index,
                 nonce: ctx.nonce,
                 precedence: precedence,
                 href: fullHref
-            }, entryCssFile.content);
+            }, entryCssFile.content));
+        } else {
+            preloadCallbacks == null ? void 0 : preloadCallbacks.push(()=>{
+                ctx.componentMod.preloadStyle(fullHref, ctx.renderOpts.crossOrigin, ctx.nonce);
+            });
+            elements.push(createElement('link', {
+                key: index,
+                rel: 'stylesheet',
+                href: fullHref,
+                precedence: precedence,
+                crossOrigin: ctx.renderOpts.crossOrigin,
+                nonce: ctx.nonce
+            }));
         }
-        preloadCallbacks == null ? void 0 : preloadCallbacks.push(()=>{
-            ctx.componentMod.preloadStyle(fullHref, ctx.renderOpts.crossOrigin, ctx.nonce);
-        });
-        return createElement('link', {
-            key: index,
-            rel: 'stylesheet',
-            href: fullHref,
-            precedence: precedence,
-            crossOrigin: ctx.renderOpts.crossOrigin,
-            nonce: ctx.nonce
-        });
-    });
+        index++;
+    }
+    return elements;
 }
 
 //# sourceMappingURL=render-css-resource.js.map