failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.3.0"];
+    const versionData = data.versions["16.3.1"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -100,7 +100,7 @@ async function patchIncorrectLockfile(dir) {
     const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.3.0",
+            version: "16.3.1",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.3.0",
+            version: "16.3.1",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/.next/standalone/node_modules/next/dist/lib/turbopack-cache-seed.js

@@ -108,7 +108,7 @@ function findSeedSource(worktreeInfo, projectDir, distDir, version) {
     const distRelToProject = _path.default.relative(projectDir, distDir);
     const currentWorktree = _path.default.resolve(worktreeInfo.worktreeRoot);
     // We are going to find the best candidate worktree
-    // based on the newest mtime of the CURRENT file in the cache directory.
+    // based on the most recently written cache directory.
     // We only look at our version
     let best;
     for (const root of [
@@ -117,23 +117,31 @@ function findSeedSource(worktreeInfo, projectDir, distDir, version) {
     ]){
         if (_path.default.resolve(root) === currentWorktree) continue;
         const versionDir = _path.default.join(root, projectRelToWorktree, distRelToProject, 'cache', 'turbopack', version);
-        const mtimeMs = currentMtimeMs(versionDir);
-        if (mtimeMs === undefined) continue;
-        if (!best || mtimeMs > best.mtimeMs) {
+        const commitTimeMs = currentCommitTimeMs(versionDir);
+        if (commitTimeMs === undefined) continue;
+        if (!best || commitTimeMs > best.commitTimeMs) {
             best = {
                 versionDir,
-                mtimeMs
+                commitTimeMs
             };
         }
     }
     return best == null ? void 0 : best.versionDir;
 }
-function currentMtimeMs(versionDir) {
+// When the cache in `versionDir` was last committed to, in epoch milliseconds, or undefined if
+// there is no usable cache there. Read from the `commit_time` the persistence layer records in
+// CURRENT.
+function currentCommitTimeMs(versionDir) {
+    let commitTime;
     try {
-        return _fs.default.statSync(_path.default.join(versionDir, 'CURRENT')).mtimeMs;
+        commitTime = JSON.parse(_fs.default.readFileSync(_path.default.join(versionDir, 'CURRENT'), 'utf8')).commit_time;
     } catch  {
+        // missing, unreadable, or not valid JSON - treat it as not a seed candidate
         return undefined;
     }
+    if (typeof commitTime !== 'string') return undefined;
+    const parsed = Date.parse(commitTime);
+    return Number.isNaN(parsed) ? undefined : parsed;
 }
 function dirHasEntries(dir) {
     try {

package/.next/standalone/node_modules/next/dist/server/app-render/app-render.js

@@ -3754,6 +3754,7 @@ function toValidationRenderContext(ctx) {
         cacheLifeProfiles: message.nextConfigSerializable.cacheLifeProfiles,
         buildId: message.buildId,
         deploymentId: message.deploymentId,
+        requestStartTime: message.request.requestStartTime,
         previouslyRevalidatedTags: [],
         refreshTagsByCacheKind: new Map(),
         runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
@@ -4693,6 +4694,7 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         isStaticGeneration: false,
         page: outerWorkStore.page,
         route: outerWorkStore.route,
+        requestStartTime: outerWorkStore.requestStartTime,
         incrementalCache: outerWorkStore.incrementalCache,
         cacheLifeProfiles: outerWorkStore.cacheLifeProfiles,
         useCacheTimeout: outerWorkStore.useCacheTimeout,

package/.next/standalone/node_modules/next/dist/server/app-render/dev-validation-worker-snapshot.js

@@ -53,7 +53,8 @@ async function buildDevValidationSnapshot(ctx, instantInputs, staticInputs, pref
             rootParams: requestStore.rootParams,
             isDraftMode: requestStore.draftMode.isEnabled,
             isHmrRefresh: requestStore.isHmrRefresh ?? false,
-            hmrRefreshHash: requestStore.hmrRefreshHash
+            hmrRefreshHash: requestStore.hmrRefreshHash,
+            requestStartTime: ctx.workStore.requestStartTime
         },
         interpolatedParams: ctx.interpolatedParams,
         requestFallbackRouteParams: ctx.fallbackRouteParams,

package/.next/standalone/node_modules/next/dist/server/async-storage/request-store.js

@@ -34,27 +34,36 @@ const _requestcookies = require("../web/spec-extension/adapters/request-cookies"
 const _cookies = require("../web/spec-extension/cookies");
 const _draftmodeprovider = require("./draft-mode-provider");
 const _utils = require("../web/utils");
-function getHeaders(headers) {
-    // `HeadersAdapter.from` wraps `IncomingHttpHeaders` (and returns a `Headers`
-    // instance unchanged) without copying, so the `delete` calls below would
-    // otherwise mutate the caller's underlying request headers. We copy first so
-    // that stripping internal headers only affects the sealed userland view, not
-    // the shared `req.headers`. The latter matters because the dev server reads
-    // the request-id headers from the raw request again (e.g. when rendering a
-    // redirect target after a server action), and mutating them there would break
-    // the dev debug channel routing.
-    const cleaned = _headers.HeadersAdapter.from(headers instanceof Headers ? new Headers(headers) : {
-        ...headers
-    });
-    for (const header of _approuterheaders.FLIGHT_HEADERS){
-        cleaned.delete(header);
-    }
+/**
+ * Internal request headers that userland `headers()` must not expose. They stay
+ * on the shared request headers for framework plumbing.
+ *
+ * Every internal header that the client can send must be listed here. The
+ * sealed userland view reads through to the shared request headers, so an
+ * omission leaks the header to userland.
+ *
+ * The names are lowercased because `HeadersAdapter.seal` matches them in
+ * lowercase.
+ */ const HIDDEN_REQUEST_HEADERS = new Set([
+    ..._approuterheaders.FLIGHT_HEADERS,
     // The client sends these dev-only request IDs so the server can route debug
-    // information back to the originating request. Like the flight headers, they
-    // are internal plumbing and must not be exposed to userland `headers()`.
-    cleaned.delete(_approuterheaders.NEXT_REQUEST_ID_HEADER);
-    cleaned.delete(_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER);
-    return _headers.HeadersAdapter.seal(cleaned);
+    // information back to the originating request. Like the flight headers,
+    // they are internal plumbing.
+    _approuterheaders.NEXT_REQUEST_ID_HEADER,
+    _approuterheaders.NEXT_HTML_REQUEST_ID_HEADER
+].map((header)=>header.toLowerCase()));
+function getHeaders(headers) {
+    // The sealed userland view must not copy the request headers.
+    // `HeadersAdapter.from` returns a `Headers` instance unchanged, so the view
+    // reads through to `NextRequest.headers`. A copy detaches `headers()` from
+    // the writes that Proxy makes to `NextRequest.headers` afterwards.
+    //
+    // The view must also not delete the internal headers. Because
+    // `HeadersAdapter.from` does not copy, a delete removes them from the shared
+    // `req.headers`. The dev server reads the request-id headers from the raw
+    // request again, for example when it renders a redirect target after a server
+    // action. Their removal breaks the dev debug channel routing.
+    return _headers.HeadersAdapter.seal(_headers.HeadersAdapter.from(headers), HIDDEN_REQUEST_HEADERS);
 }
 function getMutableCookies(headers, onUpdateCookies) {
     const cookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(headers));

package/.next/standalone/node_modules/next/dist/server/async-storage/work-store.js

@@ -61,6 +61,7 @@ function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, deploym
         cacheComponentsEnabled: renderOpts.cacheComponents,
         validationLevel: renderOpts.validationLevel,
         previouslyRevalidatedTags,
+        requestStartTime: performance.timeOrigin + performance.now(),
         refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
         runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
         shouldTrackFetchMetrics,

package/.next/standalone/node_modules/next/dist/server/config.js

@@ -1305,7 +1305,7 @@ async function applyModifyConfig(config, phase, silent, dir) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.3.0",
+                nextVersion: "16.3.1",
                 projectDir: dir
             });
         }

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

@@ -2,10 +2,26 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "installDevValidationWorker", {
-    enumerable: true,
-    get: function() {
+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");
@@ -13,6 +29,30 @@ const _devvalidationworkerglobals = require("../app-render/dev-validation-worker
 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
@@ -26,8 +66,39 @@ function installDevValidationWorker(options) {
     //
     // TODO(dev-validation-worker): raise `numWorkers` if concurrent navigations
     // across independent requests (e.g. multiple tabs) show a validation-latency
-    // tail.
+    // 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;
@@ -63,7 +134,9 @@ function installDevValidationWorker(options) {
             // `node-environment`) run runtime setup meant only for the isolated
             // worker thread, so they must not be evaluated in the parent.
             exposedMethods: [
-                'runDevValidation'
+                'runDevValidation',
+                'applyHmrUpdate',
+                'invalidateCaches'
             ],
             forkOptions: {
                 env: {
@@ -140,13 +213,19 @@ function installDevValidationWorker(options) {
             validationAbortSignal.removeEventListener('abort', propagateAbort);
         }
     };
-    // The dev server can't reach into the worker to clear its `require.cache` or
-    // manifest caches, so we drop the worker whenever the parent's caches are
-    // invalidated (HMR, route recompile). The next validation lazy-spawns a fresh
-    // worker with empty caches.
-    (0, _requirecache.onCacheInvalidation)(()=>{
-        void tearDownPool();
+    // 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);
 }
 

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

@@ -2,9 +2,25 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "runDevValidation", {
-    enumerable: true,
-    get: function() {
+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;
     }
 });
@@ -19,6 +35,8 @@ 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");
 /**
@@ -33,11 +51,12 @@ const _patcherrorinspect = require("../patch-error-inspect");
  * `loadComponents` pulled in. Frames arriving in the transported payload can
  * point at any chunk the main render touched.
  *
- * This only helps Turbopack, which writes a `.map` beside every chunk. Webpack
- * keeps its dev source maps in the compiler rather than on disk, so its frames
- * from chunks this thread never evaluated stay unresolved, and its module URLs
- * (`webpack-internal://…`) are declined below for the same reason. Frames from
- * dependencies that are not bundled never reach this point, because
+ * 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) {
@@ -59,7 +78,7 @@ const _patcherrorinspect = require("../patch-error-inspect");
             }
         }
         if (!(0, _path.isAbsolute)(chunkPath)) {
-            // Not an emitted chunk, e.g. `webpack-internal://` or `<anonymous>`.
+            // Not an emitted chunk, e.g. `<anonymous>`.
             return undefined;
         }
         const cached = payloads.get(chunkPath);
@@ -187,6 +206,29 @@ const isTestLoggingEnabled = !!(process.env.__NEXT_TEST_MODE && process.env.NEXT
         }
     }));
 }
+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

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

@@ -24,6 +24,7 @@ const _utils = require("../../shared/lib/utils");
 const _utils1 = require("../utils");
 const _loadmanifestexternal = require("../load-manifest.external");
 const _requirecache = require("./require-cache");
+const _devvalidationworkerpool = require("./dev-validation-worker-pool");
 const _renderserver = require("../lib/render-server");
 const _denormalizepagepath = require("../../shared/lib/page-path/denormalize-page-path");
 const _trace = require("../../trace");
@@ -189,6 +190,12 @@ function setupServerHmr(project, { reEvaluateAllModulesExpensive, onApplied }) {
             if (typeof __turbopack_server_hmr_apply__ === 'function') {
                 try {
                     __turbopack_server_hmr_apply__(update);
+                    // The validation worker keeps its own copy of the module graph, and
+                    // applies the same update to it.
+                    (0, _devvalidationworkerpool.mirrorModuleStateToDevValidationWorker)({
+                        type: 'apply',
+                        update
+                    });
                 } catch  {
                     // A matching runtime tried the apply and threw. Evict require.cache
                     // so the next request loads fresh, then skip onApplied. (A no-match
@@ -295,7 +302,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.3.0"
+        version: "16.3.1"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -355,7 +362,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.3.0",
+        nextVersion: "16.3.1",
         serverHmr: serverFastRefresh
     }, {
         turbopackMemoryEviction: opts.nextConfig.experimental.turbopackMemoryEvictionMode,
@@ -1716,6 +1723,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 // Clear all edge contexts
                 await (0, _renderserver.clearAllModuleContexts)();
                 resetFetch();
+                // This thread gave up on repairing its module graph in place. The
+                // validation worker cannot repair its own either, so it is dropped and
+                // the next validation loads the build output afresh.
+                (0, _devvalidationworkerpool.dropDevValidationWorker)();
                 notifyServerComponentChanges();
             },
             onApplied: (chunkPaths)=>{
@@ -1723,9 +1734,18 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 // next RSC render picks up the HMR-applied module changes. Unlike
                 // a full restart, this does NOT clear require.cache — the HMR-applied
                 // modules in devModuleCache must persist for dep preservation.
-                for (const chunkPath of chunkPaths){
-                    (0, _loadmanifestexternal.clearManifestCache)((0, _path.join)(distDir, chunkPath));
+                const manifestPaths = chunkPaths.map((chunkPath)=>(0, _path.join)(distDir, chunkPath));
+                for (const manifestPath of manifestPaths){
+                    (0, _loadmanifestexternal.clearManifestCache)(manifestPath);
                 }
+                // This path clears the manifest cache without going through
+                // `deleteCache`, so `onCacheInvalidation` does not report it to the
+                // validation worker. Report it here instead.
+                (0, _devvalidationworkerpool.mirrorModuleStateToDevValidationWorker)({
+                    type: 'invalidate',
+                    filePaths: manifestPaths,
+                    evictModules: false
+                });
                 notifyServerComponentChanges();
             }
         });

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

@@ -234,7 +234,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.3.0"
+            version: "16.3.1"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

package/.next/standalone/node_modules/next/dist/server/dev/use-cache-probe-worker.js

@@ -160,6 +160,7 @@ function buildProbeWorkStore(msg) {
         cacheLifeProfiles: msg.nextConfigSerializable.cacheLifeProfiles,
         buildId: msg.buildId,
         deploymentId: msg.deploymentId,
+        requestStartTime: msg.request.requestStartTime,
         // Empty values for cache-handler / RDC bookkeeping. The `useCacheProbeMode`
         // branch in `cache()` returns before any code that reads or writes these
         // fields, so the values can never be observed.

package/.next/standalone/node_modules/next/dist/server/image-optimizer.js

@@ -210,6 +210,7 @@ function getSharp(concurrency, operationCache) {
                 'VipsForeignLoadJpeg',
                 'VipsForeignLoadNsgif',
                 'VipsForeignLoadPng',
+                'VipsForeignLoadSvg',
                 'VipsForeignLoadTiff',
                 'VipsForeignLoadWebp'
             ]

package/.next/standalone/node_modules/next/dist/server/lib/app-info-log.js

@@ -79,7 +79,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     const versionSuffix = logBundler ? ` (${(0, _bundler.bundlerName)((0, _bundler.getBundlerFromEnv)())})` : '';
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.0"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.1"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

package/.next/standalone/node_modules/next/dist/server/lib/encode-header-safe.js

@@ -0,0 +1,44 @@
+/**
+ * Percent-encode every character other than horizontal tab and printable ASCII
+ * so a value can be safely serialized into an HTTP header.
+ *
+ * Node's `validateHeaderValue` and `fetch`'s ByteString conversion accept
+ * different character ranges. Restricting values to `\t\x20-\x7e` produces a
+ * conservative representation that both can serialize. Characters outside a
+ * transport's accepted range (Hebrew, Arabic, Chinese, emoji, …) would
+ * otherwise throw `ERR_INVALID_CHAR` or a `TypeError`, which crashes ISR or
+ * fails a cache read on every affected request.
+ *
+ * Cache tags are encoded at the public boundaries — tag construction
+ * (`getImplicitTags`, `validateTags`) and invalidation input
+ * (`revalidatePath`, `revalidateTag`, `updateTag`) — so storage, comparison,
+ * and the wire all see the same canonical form.
+ *
+ * The class is narrower than either transport accepts. Everything inside it
+ * passes through byte-for-byte, including `,`, `/`, `%`, `[`, `]`, `_`, `-` and
+ * `\t`, which preserves the comma-separated header format and the
+ * dynamic-segment markers in derived tags (`_N_T_/[slug]/page`).
+ *
+ * Properties:
+ * - Fast-path: input that already fits the class is returned unchanged. This
+ *   makes the encoder idempotent on already-encoded `%xx` sequences.
+ * - Matches *runs* of out-of-class code units so surrogate pairs (e.g. an
+ *   emoji) are handed to `encodeURIComponent` as a complete code point — a
+ *   per-code-unit regex would split the pair and throw `URIError`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeHeaderSafe", {
+    enumerable: true,
+    get: function() {
+        return encodeHeaderSafe;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeHeaderSafe(value) {
+    return OUT_OF_CLASS_CHAR.test(value) ? value.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : value;
+}
+
+//# sourceMappingURL=encode-header-safe.js.map

package/.next/standalone/node_modules/next/dist/server/lib/implicit-tags.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "getImplicitTags", {
 });
 const _constants = require("../../lib/constants");
 const _handlers = require("../use-cache/handlers");
-const _encodecachetag = require("./encode-cache-tag");
+const _encodeheadersafe = require("./encode-header-safe");
 const _lazyresult = require("./lazy-result");
 const getDerivedTags = (pathname)=>{
     const derivedTags = [
@@ -62,13 +62,13 @@ async function getImplicitTags(page, pathname, fallbackRouteParams) {
     // `x-next-cache-tags`. Idempotent on already-ASCII input.
     const derivedTags = getDerivedTags(page);
     for (let tag of derivedTags){
-        tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`);
+        tag = (0, _encodeheadersafe.encodeHeaderSafe)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`);
         tags.add(tag);
     }
     // Add the tags from the pathname. If the route has unknown params, we don't
     // want to add the pathname as a tag, as it will be invalid.
     if (pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
-        const tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
+        const tag = (0, _encodeheadersafe.encodeHeaderSafe)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
         tags.add(tag);
     }
     if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {

package/.next/standalone/node_modules/next/dist/server/lib/patch-fetch.js

@@ -44,7 +44,7 @@ const _workunitasyncstorageexternal = require("../app-render/work-unit-async-sto
 const _responsecache = require("../response-cache");
 const _cloneresponse = require("./clone-response");
 const _stagedrendering = require("../app-render/staged-rendering");
-const _encodecachetag = require("./encode-cache-tag");
+const _encodeheadersafe = require("./encode-header-safe");
 const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
@@ -94,7 +94,7 @@ function validateTags(tags, description) {
             // Encode so a non-ASCII tag can be safely serialized into the
             // `x-next-cache-tags` HTTP header without tripping Node's header
             // validation. Length is checked on the raw input above.
-            validTags.push((0, _encodecachetag.encodeCacheTag)(tag));
+            validTags.push((0, _encodeheadersafe.encodeHeaderSafe)(tag));
         }
         if (validTags.length > _constants1.NEXT_CACHE_TAG_MAX_ITEMS) {
             console.warn(`Warning: exceeded max tag count for ${description}, dropped tags:`, tags.slice(i).join(', '));

package/.next/standalone/node_modules/next/dist/server/lib/start-server.js

@@ -177,7 +177,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.3.0"})`;
+    process.title = `next-server (v${"16.3.1"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{