@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/use-cache/use-cache-errors.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    UseCacheTimeoutError: null,
-    isUseCacheTimeoutError: null
+    NestedDynamicUseCacheError: null,
+    UseCacheDeadlockError: null,
+    UseCacheTimeoutError: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -13,24 +14,46 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    NestedDynamicUseCacheError: function() {
+        return NestedDynamicUseCacheError;
+    },
+    UseCacheDeadlockError: function() {
+        return UseCacheDeadlockError;
+    },
     UseCacheTimeoutError: function() {
         return UseCacheTimeoutError;
-    },
-    isUseCacheTimeoutError: function() {
-        return isUseCacheTimeoutError;
     }
 });
-const USE_CACHE_TIMEOUT_ERROR_CODE = 'USE_CACHE_TIMEOUT';
 class UseCacheTimeoutError extends Error {
     constructor(){
-        super('Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".'), this.digest = USE_CACHE_TIMEOUT_ERROR_CODE;
+        super('Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E236",
+            enumerable: false,
+            configurable: true
+        });
     }
 }
-function isUseCacheTimeoutError(err) {
-    if (typeof err !== 'object' || err === null || !('digest' in err) || typeof err.digest !== 'string') {
-        return false;
+class UseCacheDeadlockError extends Error {
+    constructor(){
+        super('Filling a "use cache" entry appears to be stuck on shared state from the outer render scope. The same function completed when run in isolation, which usually means a module-scoped value (for example a top-level Map used to dedupe fetches) is joining a promise created outside the cache. "use cache" already dedupes calls with the same arguments — within a request and across requests on the same server instance — so the surrounding dedupe layer is both unnecessary and the likely cause. Remove it and rely on "use cache" alone for deduping.');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1181",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+class NestedDynamicUseCacheError extends Error {
+    constructor(){
+        super('This "use cache" has a dynamic cache life that was propagated to its parent.');
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1243",
+            enumerable: false,
+            configurable: true
+        });
+        this.name = 'Nested dynamic "use cache"';
     }
-    return err.digest === USE_CACHE_TIMEOUT_ERROR_CODE;
 }
 
 //# sourceMappingURL=use-cache-errors.js.map

package/dist/node_modules/next/dist/server/use-cache/use-cache-probe-globals.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getUseCacheProbe: null,
+    setUseCacheProbe: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getUseCacheProbe: function() {
+        return getUseCacheProbe;
+    },
+    setUseCacheProbe: function() {
+        return setUseCacheProbe;
+    }
+});
+// Cross-module handoff for the `'use cache'` hang-detection probe. A symbol on
+// `globalThis` decouples the dev-server entry point (which installs the
+// jest-worker pool) from the read site inside `use-cache-wrapper.ts` — avoiding
+// a direct import of dev-only code from the use-cache module. In any process
+// where the symbol is not set (prod, edge, unit tests, the probe worker itself)
+// `getUseCacheProbe()` returns undefined, which doubles as the recursion guard
+// against a probe spawning another probe.
+const SYMBOL = Symbol.for('next.dev.useCacheProbe');
+function setUseCacheProbe(fn) {
+    ;
+    globalThis[SYMBOL] = fn;
+}
+function getUseCacheProbe() {
+    return globalThis[SYMBOL];
+}
+
+//# sourceMappingURL=use-cache-probe-globals.js.map

package/dist/node_modules/next/dist/server/use-cache/use-cache-probe-scheduler.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setupProbeScheduler", {
+    enumerable: true,
+    get: function() {
+        return setupProbeScheduler;
+    }
+});
+const _usecacheprobeglobals = require("./use-cache-probe-globals");
+const PROBE_THRESHOLD_MS = 10000;
+const MIN_PROBE_BUDGET_MS = 3000;
+function setupProbeScheduler(opts) {
+    const { workStore, outerRequestStore, cacheContext, encodedArguments, fillDeadlineAt, stream, abortSignal, onProbeCompleted } = opts;
+    if (fillDeadlineAt - performance.now() < PROBE_THRESHOLD_MS + MIN_PROBE_BUDGET_MS) {
+        return stream;
+    }
+    const probe = (0, _usecacheprobeglobals.getUseCacheProbe)();
+    if (!probe) {
+        return stream;
+    }
+    let lastChunkAt = performance.now();
+    let idleTimer;
+    const startProbe = ()=>{
+        if (abortSignal.aborted) {
+            return;
+        }
+        const probeStartedAtChunk = lastChunkAt;
+        // Computed when the probe is about to run so it gets the actual remaining
+        // budget, not a stale value baked in at scheduler setup. Reserves a 1s
+        // buffer so the probe's internal timeout fires before the outer render
+        // timeout.
+        const probeInternalTimeoutMs = fillDeadlineAt - performance.now() - 1000;
+        probe({
+            page: workStore.page,
+            route: workStore.route,
+            id: cacheContext.functionId,
+            kind: cacheContext.handlerKind,
+            encodedArguments,
+            // Built lazily because most fills complete before the idle timer fires;
+            // only worth assembling once we know the probe is running.
+            request: {
+                headers: Array.from(outerRequestStore.headers.entries()),
+                cookieHeader: outerRequestStore.headers.get('cookie') ?? undefined,
+                urlPathname: outerRequestStore.url.pathname,
+                urlSearch: outerRequestStore.url.search,
+                rootParams: outerRequestStore.rootParams ?? {},
+                isDraftMode: workStore.isDraftMode ?? false,
+                isHmrRefresh: outerRequestStore.isHmrRefresh ?? false,
+                hmrRefreshHash: outerRequestStore.hmrRefreshHash,
+                requestStartTime: workStore.requestStartTime
+            },
+            timeoutMs: probeInternalTimeoutMs
+        }).then((completed)=>{
+            // Mid-probe recovery: chunks arrived while the probe was running, so
+            // the main stream is making progress. Discard the probe's result rather
+            // than reporting a deadlock that no longer holds.
+            if (lastChunkAt > probeStartedAtChunk) {
+                return;
+            }
+            if (completed && !abortSignal.aborted) {
+                onProbeCompleted();
+            }
+        }, ()=>{
+        // Probe failures are inconclusive; fall back to the regular cache-fill
+        // timeout.
+        });
+    };
+    const scheduleAfterIdle = ()=>{
+        if (idleTimer !== undefined || abortSignal.aborted) {
+            return;
+        }
+        const now = performance.now();
+        const idleFor = now - lastChunkAt;
+        const wait = Math.max(0, PROBE_THRESHOLD_MS - idleFor);
+        // Skip scheduling if the outer fill timeout will fire before the probe
+        // could even start running with at least a minimum useful budget. Without
+        // this check, a chunk arriving late in the fill could reschedule a probe
+        // that the outer timeout would then abort — wasted worker spawn for a probe
+        // that can't meaningfully complete.
+        if (fillDeadlineAt - now < wait + MIN_PROBE_BUDGET_MS) {
+            return;
+        }
+        idleTimer = setTimeout(()=>{
+            idleTimer = undefined;
+            if (abortSignal.aborted) {
+                return;
+            }
+            const idleNow = performance.now() - lastChunkAt;
+            if (idleNow < PROBE_THRESHOLD_MS) {
+                // A chunk arrived since we set this timer; reschedule.
+                scheduleAfterIdle();
+                return;
+            }
+            startProbe();
+        }, wait);
+    };
+    abortSignal.addEventListener('abort', ()=>{
+        if (idleTimer !== undefined) {
+            clearTimeout(idleTimer);
+            idleTimer = undefined;
+        }
+    }, {
+        once: true
+    });
+    scheduleAfterIdle();
+    return stream.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            lastChunkAt = performance.now();
+            scheduleAfterIdle();
+            controller.enqueue(chunk);
+        }
+    }));
+}
+
+//# sourceMappingURL=use-cache-probe-scheduler.js.map