conductor-oss 0.61.21 → 0.61.23

package/web/.next/standalone/node_modules/next/dist/server/lib/encode-cache-tag.js

@@ -0,0 +1,45 @@
+/**
+ * Percent-encode every character outside printable ASCII so a tag value can be
+ * safely serialized as part of the `x-next-cache-tags` HTTP header.
+ *
+ * Node's `validateHeaderValue` rejects any code unit outside `\t\x20-\x7e`, so
+ * a matched route path or user-supplied tag containing a non-ASCII character
+ * (Hebrew, Arabic, Chinese, emoji, …) would otherwise throw `ERR_INVALID_CHAR`
+ * and crash ISR on every affected request.
+ *
+ * This is applied 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 ASCII-safe form.
+ *
+ * The character class `[\t\x20-\x7e]` mirrors Node's `validHdrChars` table —
+ * `\t` plus printable ASCII through `~`. Anything outside that is rejected
+ * by `validateHeaderValue`, so we encode runs of those characters and leave
+ * everything else (`,`, `/`, `%`, `[`, `]`, `_`, `-`, `\t`, …) byte-for-byte
+ * unchanged. This 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 validation 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, "encodeCacheTag", {
+    enumerable: true,
+    get: function() {
+        return encodeCacheTag;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeCacheTag(tag) {
+    return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : tag;
+}
+
+//# sourceMappingURL=encode-cache-tag.js.map

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

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "getImplicitTags", {
 });
 const _constants = require("../../lib/constants");
 const _handlers = require("../use-cache/handlers");
+const _encodecachetag = require("./encode-cache-tag");
 const _lazyresult = require("./lazy-result");
 const getDerivedTags = (pathname)=>{
     const derivedTags = [
@@ -49,16 +50,18 @@ const getDerivedTags = (pathname)=>{
 }
 async function getImplicitTags(page, pathname, fallbackRouteParams) {
     const tags = new Set();
-    // Add the derived tags from the page.
+    // Add the derived tags from the page. Encode each tag so a non-ASCII
+    // pathname doesn't trip header validation when written to
+    // `x-next-cache-tags`. Idempotent on already-ASCII input.
     const derivedTags = getDerivedTags(page);
     for (let tag of derivedTags){
-        tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`;
+        tag = (0, _encodecachetag.encodeCacheTag)(`${_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 = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`;
+        const tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
         tags.add(tag);
     }
     if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {

package/web/.next/standalone/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -37,6 +37,33 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function toHex(buffer) {
+    // Hex-encode body bytes losslessly: decoding as UTF-8 would collapse
+    // distinct bytes (0xff/0xfe to U+FFFD) and collide; Buffer isn't on edge.
+    const bytes = isArrayBuffer(buffer) ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let hex = '';
+    for (const byte of bytes){
+        hex += byte.toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+// Duck typing to support Edge runtime
+// TODO: Switch to instanceof checks once Edge runtime is removed.
+function isArrayBuffer(buffer) {
+    return !('buffer' in buffer);
+}
+function isBodyByteSequence(body) {
+    return typeof body === 'object' && 'byteLength' in body;
+}
+function isBodyReadableStream(body) {
+    return typeof body.getReader === 'function';
+}
+function isBodyFormDataOrURLSearchParams(body) {
+    return typeof body.keys === 'function';
+}
+function isBodyBlob(body) {
+    return typeof body.arrayBuffer === 'function';
+}
 class CacheHandler {
     // eslint-disable-next-line
     constructor(_ctx){}
@@ -47,6 +74,19 @@ class CacheHandler {
     async revalidateTag(_tags, _durations) {}
     resetRequestCache() {}
 }
+async function hashString(cacheString) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        const encoder = new TextEncoder();
+        const buffer = encoder.encode(cacheString);
+        return toHex(await crypto.subtle.digest('SHA-256', buffer));
+    } else {
+        const crypto1 = require('crypto');
+        return crypto1.createHash('sha256').update(cacheString).digest('hex');
+    }
+}
+// this should be bumped anytime a fix is made to cache entries
+// that should bust the cache
+const MAIN_KEY_PREFIX = 'v4';
 class IncrementalCache {
     static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
     constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys }){
@@ -161,38 +201,34 @@ class IncrementalCache {
         var _this_cacheHandler;
         return (_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.revalidateTag(tags, durations);
     }
+    async generateSimpleCacheKey(input) {
+        const cacheString = JSON.stringify([
+            MAIN_KEY_PREFIX,
+            this.fetchCacheKeyPrefix || '',
+            input
+        ]);
+        return hashString(cacheString);
+    }
     // x-ref: https://github.com/facebook/react/blob/2655c9354d8e1c54ba888444220f63e836925caa/packages/react/src/ReactFetch.js#L23
     async generateCacheKey(url, init = {}) {
-        // this should be bumped anytime a fix is made to cache entries
-        // that should bust the cache
-        const MAIN_KEY_PREFIX = 'v3';
         const bodyChunks = [];
         const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        if (init.body) {
-            // handle Uint8Array body
-            if (init.body instanceof Uint8Array) {
-                bodyChunks.push(decoder.decode(init.body));
-                init._ogBody = init.body;
-            } else if (typeof init.body.getReader === 'function') {
-                const readableBody = init.body;
+        // Will be set implementing https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+        let bodyType = null;
+        const body = init.body;
+        if (body) {
+            if (isBodyByteSequence(body)) {
+                bodyChunks.push(`bytes:${toHex(body)}`);
+                init._ogBody = body;
+            } else if (isBodyReadableStream(body)) {
+                const readableBody = body;
                 const chunks = [];
                 try {
                     await readableBody.pipeTo(new WritableStream({
                         write (chunk) {
-                            if (typeof chunk === 'string') {
-                                chunks.push(encoder.encode(chunk));
-                                bodyChunks.push(chunk);
-                            } else {
-                                chunks.push(chunk);
-                                bodyChunks.push(decoder.decode(chunk, {
-                                    stream: true
-                                }));
-                            }
+                            chunks.push(typeof chunk === 'string' ? encoder.encode(chunk) : chunk);
                         }
                     }));
-                    // Flush the decoder.
-                    bodyChunks.push(decoder.decode());
                     // Create a new buffer with all the chunks.
                     const length = chunks.reduce((total, arr)=>total + arr.length, 0);
                     const arrayBuffer = new Uint8Array(length);
@@ -202,39 +238,46 @@ class IncrementalCache {
                         arrayBuffer.set(chunk, offset);
                         offset += chunk.length;
                     }
-                    ;
+                    bodyChunks.push(`bytes:${toHex(arrayBuffer)}`);
                     init._ogBody = arrayBuffer;
                 } catch (err) {
                     console.error('Problem reading body', err);
                 }
-            } else if (typeof init.body.keys === 'function') {
-                const formData = init.body;
-                init._ogBody = init.body;
-                for (const key of new Set([
-                    ...formData.keys()
-                ])){
-                    const values = formData.getAll(key);
-                    bodyChunks.push(`${key}=${(await Promise.all(values.map(async (val)=>{
-                        if (typeof val === 'string') {
-                            return val;
-                        } else {
-                            return await val.text();
-                        }
-                    }))).join(',')}`);
+            } else if (isBodyFormDataOrURLSearchParams(body)) {
+                bodyType = String(body) === '[object FormData]' ? 'multipart/form-data; boundary=' : 'application/x-www-form-urlencoded;charset=UTF-8';
+                const iterable = body;
+                init._ogBody = body;
+                // Separate, tagged chunks so `["a","b"]` can't collide with `["a,b"]`.
+                for (const [key, val] of iterable.entries()){
+                    bodyChunks.push(`key:${key}`);
+                    if (typeof val === 'string') {
+                        bodyChunks.push(`str:${val}`);
+                    } else {
+                        bodyChunks.push('file', val.name, val.type, `bytes:${toHex(await val.arrayBuffer())}`);
+                    }
                 }
             // handle blob body
-            } else if (typeof init.body.arrayBuffer === 'function') {
-                const blob = init.body;
+            } else if (isBodyBlob(body)) {
+                const blob = body;
                 const arrayBuffer = await blob.arrayBuffer();
-                bodyChunks.push(await blob.text());
+                bodyChunks.push('blob', blob.type, `bytes:${toHex(arrayBuffer)}`);
                 init._ogBody = new Blob([
                     arrayBuffer
                 ], {
                     type: blob.type
                 });
-            } else if (typeof init.body === 'string') {
-                bodyChunks.push(init.body);
-                init._ogBody = init.body;
+                bodyType = blob.type;
+            } else if (typeof body === 'string') {
+                bodyChunks.push(`str:${body}`);
+                init._ogBody = body;
+                bodyType = 'text/plain;charset=UTF-8';
+            } else {
+                body;
+                throw Object.defineProperty(new Error(`Unsupported body type: ${typeof body}`), "__NEXT_ERROR_CODE", {
+                    value: "E1145",
+                    enumerable: false,
+                    configurable: true
+                });
             }
         }
         const headers = typeof (init.headers || {}).keys === 'function' ? Object.fromEntries(init.headers) : Object.assign({}, init.headers);
@@ -247,6 +290,9 @@ class IncrementalCache {
             this.fetchCacheKeyPrefix || '',
             url,
             init.method,
+            // Ensures default Content-Type is part of the cache key
+            // TODO: Only necessary when headers are not used from the Request instance
+            bodyType,
             headers,
             init.mode,
             init.redirect,
@@ -257,16 +303,7 @@ class IncrementalCache {
             init.cache,
             bodyChunks
         ]);
-        if (process.env.NEXT_RUNTIME === 'edge') {
-            function bufferToHex(buffer) {
-                return Array.prototype.map.call(new Uint8Array(buffer), (b)=>b.toString(16).padStart(2, '0')).join('');
-            }
-            const buffer = encoder.encode(cacheString);
-            return bufferToHex(await crypto.subtle.digest('SHA-256', buffer));
-        } else {
-            const crypto1 = require('crypto');
-            return crypto1.createHash('sha256').update(cacheString).digest('hex');
-        }
+        return hashString(cacheString);
     }
     async get(cacheKey, ctx) {
         var _this_cacheHandler, _cacheData_value;

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

@@ -42,6 +42,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 isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
@@ -86,7 +87,10 @@ function validateTags(tags, description) {
                 reason: `exceeded max length of ${_constants1.NEXT_CACHE_TAG_MAX_LENGTH}`
             });
         } else {
-            validTags.push(tag);
+            // 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));
         }
         if (validTags.length > _constants1.NEXT_CACHE_TAG_MAX_ITEMS) {
             console.warn(`Warning: exceeded max tag count for ${description}, dropped tags:`, tags.slice(i).join(', '));
@@ -250,6 +254,19 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
                 return originFetch(input, init);
             }
             const isRequestInput = input && typeof input === 'object' && typeof input.method === 'string';
+            // With `fetch(new Request(url), init)`, native fetch lets `init`
+            // override the base Request. Merge them into a single effective Request
+            // so cacheability, the cache key, and the upstream request all describe
+            // the same thing.
+            if (isRequestInput && init) {
+                // `next` (revalidate/tags) is Next-specific and dropped by
+                // `new Request`, so keep it on `init` and move the rest onto input.
+                const { next, ...overrides } = init;
+                input = new Request(input, overrides);
+                init = next ? {
+                    next
+                } : undefined;
+            }
             const getRequestMeta = (field)=>{
                 // If request input is present but init is not, retrieve from input first.
                 const value = init == null ? void 0 : init[field];
@@ -579,8 +596,8 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
             if (incrementalCache && (isCacheableRevalidate || serverComponentsHmrCache)) {
                 try {
                     cacheKey = await incrementalCache.generateCacheKey(fetchUrl, isRequestInput ? input : init);
-                } catch (err) {
-                    console.error(`Failed to generate cache key for`, input);
+                } catch (cause) {
+                    console.error(`Failed to generate cache key for`, input, cause);
                 }
             }
             const fetchIdx = workStore.nextFetchId ?? 1;

package/web/.next/standalone/node_modules/next/dist/server/lib/router-utils/proxy-request.js

@@ -22,6 +22,10 @@ async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTime
     delete parsedUrl.query;
     parsedUrl.search = (0, _serverrouteutils.stringifyQuery)(req, query);
     const target = _url.default.format(parsedUrl);
+    // Keep in mind that a WHATWG URL's hostname and the parsedUrl's hostname
+    // are not strictly equal due to lowercasing, IDN translation, IPv4 and IPv6 normalization, etc.
+    // We just make sure this is a valid URL since http-proxy doesn't validate.
+    new URL(target);
     const HttpProxy = require('next/dist/compiled/http-proxy');
     const proxy = new HttpProxy({
         target,

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

@@ -178,7 +178,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.2.6"})`;
+    process.title = `next-server (v${"16.2.11"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/web/.next/standalone/node_modules/next/dist/shared/lib/errors/canary-only-config-error.js

@@ -21,7 +21,7 @@ _export(exports, {
     }
 });
 function isStableBuild() {
-    return !"16.2.6"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+    return !"16.2.11"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
 }
 class CanaryOnlyConfigError extends Error {
     constructor(arg){

package/web/.next/standalone/node_modules/next/dist/shared/lib/router/router.js

@@ -150,7 +150,14 @@ function getMiddlewareData(source, response, options) {
                 let as = (0, _addlocale.addLocale)(pathnameInfo.pathname, pathnameInfo.locale);
                 if ((0, _isdynamic.isDynamicRoute)(as) || !rewriteHeader && pages.includes((0, _normalizelocalepath.normalizeLocalePath)((0, _removebasepath.removeBasePath)(as), options.router.locales).pathname)) {
                     const parsedSource = (0, _getnextpathnameinfo.getNextPathnameInfo)((0, _parserelativeurl.parseRelativeUrl)(source).pathname, {
-                        nextConfig: process.env.__NEXT_HAS_REWRITES ? undefined : nextConfig,
+                        // Pass basePath (and trailingSlash) so the basePath prefix is
+                        // stripped before the `_next/data/` check, but omit `i18n` so the
+                        // locale prefix is preserved here — the rewrite resolver below
+                        // handles the locale-prefixed `as`.
+                        nextConfig: {
+                            basePath: nextConfig.basePath,
+                            trailingSlash: nextConfig.trailingSlash
+                        },
                         parseData: true
                     });
                     as = (0, _addbasepath.addBasePath)(parsedSource.pathname);

package/web/.next/standalone/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -215,7 +215,8 @@ function prepareDestination(args) {
     let destHostnameCompiler;
     if (destHostname) {
         destHostnameCompiler = (0, _routematchutils.safeCompile)(destHostname, {
-            validate: false
+            validate: false,
+            encode: encodeURIComponent
         });
     }
     // update any params in query values

package/web/.next/standalone/node_modules/next/dist/shared/lib/server-reference-info.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    SERVER_REFERENCE_ID_LENGTH: null,
     extractInfoFromServerReferenceId: null,
+    mightBeServerReferenceId: null,
     omitUnusedArgs: null
 });
 function _export(target, all) {
@@ -13,13 +15,23 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    SERVER_REFERENCE_ID_LENGTH: function() {
+        return SERVER_REFERENCE_ID_LENGTH;
+    },
     extractInfoFromServerReferenceId: function() {
         return extractInfoFromServerReferenceId;
     },
+    mightBeServerReferenceId: function() {
+        return mightBeServerReferenceId;
+    },
     omitUnusedArgs: function() {
         return omitUnusedArgs;
     }
 });
+const SERVER_REFERENCE_ID_LENGTH = 42;
+function mightBeServerReferenceId(id) {
+    return id.length === SERVER_REFERENCE_ID_LENGTH;
+}
 function extractInfoFromServerReferenceId(id) {
     const infoByte = parseInt(id.slice(0, 2), 16);
     const typeBit = infoByte >> 7 & 0x1;

package/web/.next/standalone/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -81,7 +81,7 @@ function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.2.6"
+        nextVersion: "16.2.11"
     };
     return traits;
 }

package/web/.next/standalone/node_modules/next/dist/telemetry/events/swc-load-failure.js

@@ -38,7 +38,7 @@ async function eventSwcLoadFailure(event) {
     telemetry.record({
         eventName: EVENT_PLUGIN_PRESENT,
         payload: {
-            nextVersion: "16.2.6",
+            nextVersion: "16.2.11",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/web/.next/standalone/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.2.6" !== 'string') {
+    if (typeof "16.2.11" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.2.6",
+        nextVersion: "16.2.11",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,