polyrouter 1.0.13 → 1.0.15

package/app/node_modules/next/dist/server/use-cache/handlers.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", {
     getDevTieredCacheHandler: null,
     getPrivateCacheHandler: null,
     initializeCacheHandlers: null,
+    isBuiltInCacheHandler: null,
     isCustomCacheHandler: null,
     isMemoryCacheDisabled: null,
     setCacheHandler: null
@@ -38,6 +39,9 @@ _export(exports, {
     initializeCacheHandlers: function() {
         return initializeCacheHandlers;
     },
+    isBuiltInCacheHandler: function() {
+        return isBuiltInCacheHandler;
+    },
     isCustomCacheHandler: function() {
         return isCustomCacheHandler;
     },
@@ -57,6 +61,7 @@ const handlersSymbol = Symbol.for('@next/cache-handlers');
 const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
 const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
 const privateHandlerSymbol = Symbol.for('@next/cache-handlers-private');
+const builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in');
 const devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts');
 const devTieredHandlersSymbol = Symbol.for('@next/cache-handlers-dev-tiered');
 const memoryCacheDisabledSymbol = Symbol.for('@next/cache-handlers-memory-disabled');
@@ -80,6 +85,8 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
     debug == null ? void 0 : debug('initializing cache handlers');
     const handlersMap = new Map();
     reference[handlersMapSymbol] = handlersMap;
+    const builtInHandlers = new Set();
+    reference[builtInHandlersSymbol] = builtInHandlers;
     // In development, `cacheMaxMemorySize: 0` would make the built-in default
     // handler a no-op, so every reload would miss. Use a real in-memory size
     // instead so dev stays fast; the "use cache" wrapper forces a dynamic cache
@@ -95,6 +102,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         } else {
             debug == null ? void 0 : debug('setting "default" cache handler from default');
             fallback = (0, _default.createDefaultCacheHandler)(builtInSize);
+            builtInHandlers.add(fallback);
         }
         handlersMap.set('default', fallback);
         if (reference[handlersSymbol].RemoteCache) {
@@ -106,6 +114,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         }
     } else {
         const handler = (0, _default.createDefaultCacheHandler)(builtInSize);
+        builtInHandlers.add(handler);
         debug == null ? void 0 : debug('setting "default" cache handler from default');
         handlersMap.set('default', handler);
         debug == null ? void 0 : debug('setting "remote" cache handler from default');
@@ -166,6 +175,11 @@ function isCustomCacheHandler(kind) {
     }
     return ((_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.has(kind)) ?? false;
 }
+function isBuiltInCacheHandler(kind) {
+    var _reference_handlersMapSymbol, _reference_builtInHandlersSymbol;
+    const handler = (_reference_handlersMapSymbol = reference[handlersMapSymbol]) == null ? void 0 : _reference_handlersMapSymbol.get(kind);
+    return handler !== undefined && Boolean((_reference_builtInHandlersSymbol = reference[builtInHandlersSymbol]) == null ? void 0 : _reference_builtInHandlersSymbol.has(handler));
+}
 function getDevTieredCacheHandler(kind) {
     var _reference_devTieredHandlersSymbol;
     if (!process.env.__NEXT_DEV_SERVER) {

package/app/node_modules/next/dist/server/web/spec-extension/adapters/headers.js

@@ -34,6 +34,66 @@ class ReadonlyHeadersError extends Error {
         throw new ReadonlyHeadersError();
     }
 }
+/**
+ * Builds the read methods for a sealed view that exposes all of `target`.
+ */ function createPassThroughMethods(target, sealed) {
+    return {
+        get: target.get.bind(target),
+        has: target.has.bind(target),
+        getSetCookie: target.getSetCookie.bind(target),
+        keys: target.keys.bind(target),
+        values: target.values.bind(target),
+        entries: target.entries.bind(target),
+        [Symbol.iterator]: target[Symbol.iterator].bind(target),
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of target.entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
+/**
+ * Builds the read methods for a sealed view that omits the header names matched
+ * by `isHidden`.
+ */ function createHidingMethods(target, sealed, isHidden) {
+    function* entries() {
+        for (const entry of target.entries()){
+            if (!isHidden(entry[0])) {
+                yield entry;
+            }
+        }
+    }
+    return {
+        entries,
+        [Symbol.iterator]: entries,
+        get: (name)=>isHidden(name) ? null : target.get(name),
+        has: (name)=>isHidden(name) ? false : target.has(name),
+        getSetCookie: ()=>isHidden('set-cookie') ? [] : target.getSetCookie(),
+        *keys () {
+            for (const name of target.keys()){
+                if (!isHidden(name)) {
+                    yield name;
+                }
+            }
+        },
+        *values () {
+            for (const [, value] of entries()){
+                yield value;
+            }
+        },
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
 class HeadersAdapter extends Headers {
     constructor(headers){
         // We've already overridden the methods that would be called, so we're just
@@ -98,19 +158,45 @@ class HeadersAdapter extends Headers {
     /**
    * Seals a Headers instance to prevent modification by throwing an error when
    * any mutating method is called.
-   */ static seal(headers) {
-        return new Proxy(headers, {
+   *
+   * The sealed view stays live. Later writes to `headers` remain visible
+   * through it.
+   *
+   * `hidden` omits the given header names from every read operation (`get`,
+   * `has`, `getSetCookie`, `forEach`, and iteration). The names must be
+   * lowercase. The underlying headers are neither copied nor mutated, so hidden
+   * headers remain available to the framework.
+   */ static seal(headers, hidden) {
+        const isHidden = hidden && hidden.size > 0 ? (name)=>hidden.has(name.toLowerCase()) : null;
+        // The methods are built once per sealed view and reused, so repeated access
+        // returns the same function instead of a fresh closure. They are assigned
+        // after the proxy exists because `forEach` hands the proxy to its callback.
+        // Creating the proxy runs no trap, so nothing can read them before then.
+        let methods;
+        const sealed = new Proxy(headers, {
             get (target, prop, receiver) {
                 switch(prop){
                     case 'append':
                     case 'delete':
                     case 'set':
                         return ReadonlyHeadersError.callable;
+                    case Symbol.iterator:
+                        return methods[Symbol.iterator];
+                    case 'get':
+                    case 'has':
+                    case 'getSetCookie':
+                    case 'keys':
+                    case 'values':
+                    case 'entries':
+                    case 'forEach':
+                        return methods[prop];
                     default:
                         return _reflect.ReflectAdapter.get(target, prop, receiver);
                 }
             }
         });
+        methods = isHidden ? createHidingMethods(headers, sealed, isHidden) : createPassThroughMethods(headers, sealed);
+        return sealed;
     }
     /**
    * @param headers

package/app/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -82,7 +82,7 @@ async function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.3.0",
+        nextVersion: "16.3.1",
         agentName: await (0, _agentname.getAgentName)()
     };
     return traits;

package/app/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.3.0",
+            nextVersion: "16.3.1",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/app/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, _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.3.0" !== 'string') {
+    if (typeof "16.3.1" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.3.0",
+        nextVersion: "16.3.1",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/app/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.0",
+  "version": "16.3.1",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -81,8 +81,8 @@
     "next": "./dist/bin/next"
   },
   "dependencies": {
-    "@next/env": "16.3.0",
-    "@swc/helpers": "0.5.15",
+    "@next/env": "16.3.1",
+    "@swc/helpers": "0.5.23",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
     "postcss": "8.5.23",
@@ -112,14 +112,14 @@
   },
   "optionalDependencies": {
     "sharp": "^0.35.3",
-    "@next/swc-darwin-arm64": "16.3.0",
-    "@next/swc-darwin-x64": "16.3.0",
-    "@next/swc-linux-arm64-gnu": "16.3.0",
-    "@next/swc-linux-arm64-musl": "16.3.0",
-    "@next/swc-linux-x64-gnu": "16.3.0",
-    "@next/swc-linux-x64-musl": "16.3.0",
-    "@next/swc-win32-arm64-msvc": "16.3.0",
-    "@next/swc-win32-x64-msvc": "16.3.0"
+    "@next/swc-darwin-arm64": "16.3.1",
+    "@next/swc-darwin-x64": "16.3.1",
+    "@next/swc-linux-arm64-gnu": "16.3.1",
+    "@next/swc-linux-arm64-musl": "16.3.1",
+    "@next/swc-linux-x64-gnu": "16.3.1",
+    "@next/swc-linux-x64-musl": "16.3.1",
+    "@next/swc-win32-arm64-msvc": "16.3.1",
+    "@next/swc-win32-x64-msvc": "16.3.1"
   },
   "keywords": [
     "react",