react-server-dom-webpack 19.1.0-canary-32b0cad8-20250213 → 19.1.0-canary-4632e36a-20250216

package/cjs/react-server-dom-webpack-client.browser.development.js

@@ -2662,10 +2662,10 @@
       return hook.checkDCE ? !0 : !1;
     })({
       bundleType: 1,
-      version: "19.1.0-canary-32b0cad8-20250213",
+      version: "19.1.0-canary-4632e36a-20250216",
       rendererPackageName: "react-server-dom-webpack",
       currentDispatcherRef: ReactSharedInternals,
-      reconcilerVersion: "19.1.0-canary-32b0cad8-20250213",
+      reconcilerVersion: "19.1.0-canary-4632e36a-20250216",
       getCurrentComponentInfo: function () {
         return currentOwnerInDEV;
       }

package/cjs/react-server-dom-webpack-server.browser.development.js

@@ -3625,24 +3625,52 @@
       thenableState = null,
       currentComponentDebugInfo = null,
       HooksDispatcher = {
-        useMemo: function (nextCreate) {
-          return nextCreate();
+        readContext: unsupportedContext,
+        use: function (usable) {
+          if (
+            (null !== usable && "object" === typeof usable) ||
+            "function" === typeof usable
+          ) {
+            if ("function" === typeof usable.then) {
+              var index = thenableIndexCounter;
+              thenableIndexCounter += 1;
+              null === thenableState && (thenableState = []);
+              return trackUsedThenable(thenableState, usable, index);
+            }
+            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
+          }
+          if (isClientReference(usable)) {
+            if (
+              null != usable.value &&
+              usable.value.$$typeof === REACT_CONTEXT_TYPE
+            )
+              throw Error(
+                "Cannot read a Client Context from a Server Component."
+              );
+            throw Error("Cannot use() an already resolved Client Reference.");
+          }
+          throw Error(
+            "An unsupported type was passed to use(): " + String(usable)
+          );
         },
         useCallback: function (callback) {
           return callback;
         },
-        useDebugValue: function () {},
-        useDeferredValue: unsupportedHook,
-        useTransition: unsupportedHook,
-        readContext: unsupportedContext,
         useContext: unsupportedContext,
+        useEffect: unsupportedHook,
+        useImperativeHandle: unsupportedHook,
+        useLayoutEffect: unsupportedHook,
+        useInsertionEffect: unsupportedHook,
+        useMemo: function (nextCreate) {
+          return nextCreate();
+        },
         useReducer: unsupportedHook,
         useRef: unsupportedHook,
         useState: unsupportedHook,
-        useInsertionEffect: unsupportedHook,
-        useLayoutEffect: unsupportedHook,
-        useImperativeHandle: unsupportedHook,
-        useEffect: unsupportedHook,
+        useDebugValue: function () {},
+        useDeferredValue: unsupportedHook,
+        useTransition: unsupportedHook,
+        useSyncExternalStore: unsupportedHook,
         useId: function () {
           if (null === currentRequest$1)
             throw Error("useId can only be used while React is rendering");
@@ -3656,44 +3684,16 @@
           );
         },
         useHostTransitionStatus: unsupportedHook,
-        useOptimistic: unsupportedHook,
         useFormState: unsupportedHook,
         useActionState: unsupportedHook,
-        useSyncExternalStore: unsupportedHook,
-        useCacheRefresh: function () {
-          return unsupportedRefresh;
-        },
+        useOptimistic: unsupportedHook,
         useMemoCache: function (size) {
           for (var data = Array(size), i = 0; i < size; i++)
             data[i] = REACT_MEMO_CACHE_SENTINEL;
           return data;
         },
-        use: function (usable) {
-          if (
-            (null !== usable && "object" === typeof usable) ||
-            "function" === typeof usable
-          ) {
-            if ("function" === typeof usable.then) {
-              var index = thenableIndexCounter;
-              thenableIndexCounter += 1;
-              null === thenableState && (thenableState = []);
-              return trackUsedThenable(thenableState, usable, index);
-            }
-            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
-          }
-          if (isClientReference(usable)) {
-            if (
-              null != usable.value &&
-              usable.value.$$typeof === REACT_CONTEXT_TYPE
-            )
-              throw Error(
-                "Cannot read a Client Context from a Server Component."
-              );
-            throw Error("Cannot use() an already resolved Client Reference.");
-          }
-          throw Error(
-            "An unsupported type was passed to use(): " + String(usable)
-          );
+        useCacheRefresh: function () {
+          return unsupportedRefresh;
         }
       },
       currentOwner = null,

package/cjs/react-server-dom-webpack-server.browser.production.js

@@ -507,39 +507,39 @@ function getThenableStateAfterSuspending() {
   return state;
 }
 var HooksDispatcher = {
-  useMemo: function (nextCreate) {
-    return nextCreate();
-  },
+  readContext: unsupportedContext,
+  use: use,
   useCallback: function (callback) {
     return callback;
   },
-  useDebugValue: function () {},
-  useDeferredValue: unsupportedHook,
-  useTransition: unsupportedHook,
-  readContext: unsupportedContext,
   useContext: unsupportedContext,
+  useEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useMemo: function (nextCreate) {
+    return nextCreate();
+  },
   useReducer: unsupportedHook,
   useRef: unsupportedHook,
   useState: unsupportedHook,
-  useInsertionEffect: unsupportedHook,
-  useLayoutEffect: unsupportedHook,
-  useImperativeHandle: unsupportedHook,
-  useEffect: unsupportedHook,
+  useDebugValue: function () {},
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  useSyncExternalStore: unsupportedHook,
   useId: useId,
   useHostTransitionStatus: unsupportedHook,
-  useOptimistic: unsupportedHook,
   useFormState: unsupportedHook,
   useActionState: unsupportedHook,
-  useSyncExternalStore: unsupportedHook,
-  useCacheRefresh: function () {
-    return unsupportedRefresh;
-  },
+  useOptimistic: unsupportedHook,
   useMemoCache: function (size) {
     for (var data = Array(size), i = 0; i < size; i++)
       data[i] = REACT_MEMO_CACHE_SENTINEL;
     return data;
   },
-  use: use
+  useCacheRefresh: function () {
+    return unsupportedRefresh;
+  }
 };
 function unsupportedHook() {
   throw Error("This Hook is not supported in Server Components.");

package/cjs/react-server-dom-webpack-server.edge.development.js

@@ -3705,24 +3705,52 @@
       thenableState = null,
       currentComponentDebugInfo = null,
       HooksDispatcher = {
-        useMemo: function (nextCreate) {
-          return nextCreate();
+        readContext: unsupportedContext,
+        use: function (usable) {
+          if (
+            (null !== usable && "object" === typeof usable) ||
+            "function" === typeof usable
+          ) {
+            if ("function" === typeof usable.then) {
+              var index = thenableIndexCounter;
+              thenableIndexCounter += 1;
+              null === thenableState && (thenableState = []);
+              return trackUsedThenable(thenableState, usable, index);
+            }
+            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
+          }
+          if (isClientReference(usable)) {
+            if (
+              null != usable.value &&
+              usable.value.$$typeof === REACT_CONTEXT_TYPE
+            )
+              throw Error(
+                "Cannot read a Client Context from a Server Component."
+              );
+            throw Error("Cannot use() an already resolved Client Reference.");
+          }
+          throw Error(
+            "An unsupported type was passed to use(): " + String(usable)
+          );
         },
         useCallback: function (callback) {
           return callback;
         },
-        useDebugValue: function () {},
-        useDeferredValue: unsupportedHook,
-        useTransition: unsupportedHook,
-        readContext: unsupportedContext,
         useContext: unsupportedContext,
+        useEffect: unsupportedHook,
+        useImperativeHandle: unsupportedHook,
+        useLayoutEffect: unsupportedHook,
+        useInsertionEffect: unsupportedHook,
+        useMemo: function (nextCreate) {
+          return nextCreate();
+        },
         useReducer: unsupportedHook,
         useRef: unsupportedHook,
         useState: unsupportedHook,
-        useInsertionEffect: unsupportedHook,
-        useLayoutEffect: unsupportedHook,
-        useImperativeHandle: unsupportedHook,
-        useEffect: unsupportedHook,
+        useDebugValue: function () {},
+        useDeferredValue: unsupportedHook,
+        useTransition: unsupportedHook,
+        useSyncExternalStore: unsupportedHook,
         useId: function () {
           if (null === currentRequest$1)
             throw Error("useId can only be used while React is rendering");
@@ -3736,44 +3764,16 @@
           );
         },
         useHostTransitionStatus: unsupportedHook,
-        useOptimistic: unsupportedHook,
         useFormState: unsupportedHook,
         useActionState: unsupportedHook,
-        useSyncExternalStore: unsupportedHook,
-        useCacheRefresh: function () {
-          return unsupportedRefresh;
-        },
+        useOptimistic: unsupportedHook,
         useMemoCache: function (size) {
           for (var data = Array(size), i = 0; i < size; i++)
             data[i] = REACT_MEMO_CACHE_SENTINEL;
           return data;
         },
-        use: function (usable) {
-          if (
-            (null !== usable && "object" === typeof usable) ||
-            "function" === typeof usable
-          ) {
-            if ("function" === typeof usable.then) {
-              var index = thenableIndexCounter;
-              thenableIndexCounter += 1;
-              null === thenableState && (thenableState = []);
-              return trackUsedThenable(thenableState, usable, index);
-            }
-            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
-          }
-          if (isClientReference(usable)) {
-            if (
-              null != usable.value &&
-              usable.value.$$typeof === REACT_CONTEXT_TYPE
-            )
-              throw Error(
-                "Cannot read a Client Context from a Server Component."
-              );
-            throw Error("Cannot use() an already resolved Client Reference.");
-          }
-          throw Error(
-            "An unsupported type was passed to use(): " + String(usable)
-          );
+        useCacheRefresh: function () {
+          return unsupportedRefresh;
         }
       },
       currentOwner = null,

package/cjs/react-server-dom-webpack-server.edge.production.js

@@ -505,39 +505,39 @@ function getThenableStateAfterSuspending() {
   return state;
 }
 var HooksDispatcher = {
-  useMemo: function (nextCreate) {
-    return nextCreate();
-  },
+  readContext: unsupportedContext,
+  use: use,
   useCallback: function (callback) {
     return callback;
   },
-  useDebugValue: function () {},
-  useDeferredValue: unsupportedHook,
-  useTransition: unsupportedHook,
-  readContext: unsupportedContext,
   useContext: unsupportedContext,
+  useEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useMemo: function (nextCreate) {
+    return nextCreate();
+  },
   useReducer: unsupportedHook,
   useRef: unsupportedHook,
   useState: unsupportedHook,
-  useInsertionEffect: unsupportedHook,
-  useLayoutEffect: unsupportedHook,
-  useImperativeHandle: unsupportedHook,
-  useEffect: unsupportedHook,
+  useDebugValue: function () {},
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  useSyncExternalStore: unsupportedHook,
   useId: useId,
   useHostTransitionStatus: unsupportedHook,
-  useOptimistic: unsupportedHook,
   useFormState: unsupportedHook,
   useActionState: unsupportedHook,
-  useSyncExternalStore: unsupportedHook,
-  useCacheRefresh: function () {
-    return unsupportedRefresh;
-  },
+  useOptimistic: unsupportedHook,
   useMemoCache: function (size) {
     for (var data = Array(size), i = 0; i < size; i++)
       data[i] = REACT_MEMO_CACHE_SENTINEL;
     return data;
   },
-  use: use
+  useCacheRefresh: function () {
+    return unsupportedRefresh;
+  }
 };
 function unsupportedHook() {
   throw Error("This Hook is not supported in Server Components.");

package/cjs/react-server-dom-webpack-server.node.development.js

@@ -3702,24 +3702,52 @@
       thenableState = null,
       currentComponentDebugInfo = null,
       HooksDispatcher = {
-        useMemo: function (nextCreate) {
-          return nextCreate();
+        readContext: unsupportedContext,
+        use: function (usable) {
+          if (
+            (null !== usable && "object" === typeof usable) ||
+            "function" === typeof usable
+          ) {
+            if ("function" === typeof usable.then) {
+              var index = thenableIndexCounter;
+              thenableIndexCounter += 1;
+              null === thenableState && (thenableState = []);
+              return trackUsedThenable(thenableState, usable, index);
+            }
+            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
+          }
+          if (isClientReference(usable)) {
+            if (
+              null != usable.value &&
+              usable.value.$$typeof === REACT_CONTEXT_TYPE
+            )
+              throw Error(
+                "Cannot read a Client Context from a Server Component."
+              );
+            throw Error("Cannot use() an already resolved Client Reference.");
+          }
+          throw Error(
+            "An unsupported type was passed to use(): " + String(usable)
+          );
         },
         useCallback: function (callback) {
           return callback;
         },
-        useDebugValue: function () {},
-        useDeferredValue: unsupportedHook,
-        useTransition: unsupportedHook,
-        readContext: unsupportedContext,
         useContext: unsupportedContext,
+        useEffect: unsupportedHook,
+        useImperativeHandle: unsupportedHook,
+        useLayoutEffect: unsupportedHook,
+        useInsertionEffect: unsupportedHook,
+        useMemo: function (nextCreate) {
+          return nextCreate();
+        },
         useReducer: unsupportedHook,
         useRef: unsupportedHook,
         useState: unsupportedHook,
-        useInsertionEffect: unsupportedHook,
-        useLayoutEffect: unsupportedHook,
-        useImperativeHandle: unsupportedHook,
-        useEffect: unsupportedHook,
+        useDebugValue: function () {},
+        useDeferredValue: unsupportedHook,
+        useTransition: unsupportedHook,
+        useSyncExternalStore: unsupportedHook,
         useId: function () {
           if (null === currentRequest$1)
             throw Error("useId can only be used while React is rendering");
@@ -3733,44 +3761,16 @@
           );
         },
         useHostTransitionStatus: unsupportedHook,
-        useOptimistic: unsupportedHook,
         useFormState: unsupportedHook,
         useActionState: unsupportedHook,
-        useSyncExternalStore: unsupportedHook,
-        useCacheRefresh: function () {
-          return unsupportedRefresh;
-        },
+        useOptimistic: unsupportedHook,
         useMemoCache: function (size) {
           for (var data = Array(size), i = 0; i < size; i++)
             data[i] = REACT_MEMO_CACHE_SENTINEL;
           return data;
         },
-        use: function (usable) {
-          if (
-            (null !== usable && "object" === typeof usable) ||
-            "function" === typeof usable
-          ) {
-            if ("function" === typeof usable.then) {
-              var index = thenableIndexCounter;
-              thenableIndexCounter += 1;
-              null === thenableState && (thenableState = []);
-              return trackUsedThenable(thenableState, usable, index);
-            }
-            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
-          }
-          if (isClientReference(usable)) {
-            if (
-              null != usable.value &&
-              usable.value.$$typeof === REACT_CONTEXT_TYPE
-            )
-              throw Error(
-                "Cannot read a Client Context from a Server Component."
-              );
-            throw Error("Cannot use() an already resolved Client Reference.");
-          }
-          throw Error(
-            "An unsupported type was passed to use(): " + String(usable)
-          );
+        useCacheRefresh: function () {
+          return unsupportedRefresh;
         }
       },
       currentOwner = null,

package/cjs/react-server-dom-webpack-server.node.production.js

@@ -525,39 +525,39 @@ function getThenableStateAfterSuspending() {
   return state;
 }
 var HooksDispatcher = {
-  useMemo: function (nextCreate) {
-    return nextCreate();
-  },
+  readContext: unsupportedContext,
+  use: use,
   useCallback: function (callback) {
     return callback;
   },
-  useDebugValue: function () {},
-  useDeferredValue: unsupportedHook,
-  useTransition: unsupportedHook,
-  readContext: unsupportedContext,
   useContext: unsupportedContext,
+  useEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useMemo: function (nextCreate) {
+    return nextCreate();
+  },
   useReducer: unsupportedHook,
   useRef: unsupportedHook,
   useState: unsupportedHook,
-  useInsertionEffect: unsupportedHook,
-  useLayoutEffect: unsupportedHook,
-  useImperativeHandle: unsupportedHook,
-  useEffect: unsupportedHook,
+  useDebugValue: function () {},
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  useSyncExternalStore: unsupportedHook,
   useId: useId,
   useHostTransitionStatus: unsupportedHook,
-  useOptimistic: unsupportedHook,
   useFormState: unsupportedHook,
   useActionState: unsupportedHook,
-  useSyncExternalStore: unsupportedHook,
-  useCacheRefresh: function () {
-    return unsupportedRefresh;
-  },
+  useOptimistic: unsupportedHook,
   useMemoCache: function (size) {
     for (var data = Array(size), i = 0; i < size; i++)
       data[i] = REACT_MEMO_CACHE_SENTINEL;
     return data;
   },
-  use: use
+  useCacheRefresh: function () {
+    return unsupportedRefresh;
+  }
 };
 function unsupportedHook() {
   throw Error("This Hook is not supported in Server Components.");

package/cjs/react-server-dom-webpack-server.node.unbundled.development.js

@@ -3665,24 +3665,52 @@
       thenableState = null,
       currentComponentDebugInfo = null,
       HooksDispatcher = {
-        useMemo: function (nextCreate) {
-          return nextCreate();
+        readContext: unsupportedContext,
+        use: function (usable) {
+          if (
+            (null !== usable && "object" === typeof usable) ||
+            "function" === typeof usable
+          ) {
+            if ("function" === typeof usable.then) {
+              var index = thenableIndexCounter;
+              thenableIndexCounter += 1;
+              null === thenableState && (thenableState = []);
+              return trackUsedThenable(thenableState, usable, index);
+            }
+            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
+          }
+          if (isClientReference(usable)) {
+            if (
+              null != usable.value &&
+              usable.value.$$typeof === REACT_CONTEXT_TYPE
+            )
+              throw Error(
+                "Cannot read a Client Context from a Server Component."
+              );
+            throw Error("Cannot use() an already resolved Client Reference.");
+          }
+          throw Error(
+            "An unsupported type was passed to use(): " + String(usable)
+          );
         },
         useCallback: function (callback) {
           return callback;
         },
-        useDebugValue: function () {},
-        useDeferredValue: unsupportedHook,
-        useTransition: unsupportedHook,
-        readContext: unsupportedContext,
         useContext: unsupportedContext,
+        useEffect: unsupportedHook,
+        useImperativeHandle: unsupportedHook,
+        useLayoutEffect: unsupportedHook,
+        useInsertionEffect: unsupportedHook,
+        useMemo: function (nextCreate) {
+          return nextCreate();
+        },
         useReducer: unsupportedHook,
         useRef: unsupportedHook,
         useState: unsupportedHook,
-        useInsertionEffect: unsupportedHook,
-        useLayoutEffect: unsupportedHook,
-        useImperativeHandle: unsupportedHook,
-        useEffect: unsupportedHook,
+        useDebugValue: function () {},
+        useDeferredValue: unsupportedHook,
+        useTransition: unsupportedHook,
+        useSyncExternalStore: unsupportedHook,
         useId: function () {
           if (null === currentRequest$1)
             throw Error("useId can only be used while React is rendering");
@@ -3696,44 +3724,16 @@
           );
         },
         useHostTransitionStatus: unsupportedHook,
-        useOptimistic: unsupportedHook,
         useFormState: unsupportedHook,
         useActionState: unsupportedHook,
-        useSyncExternalStore: unsupportedHook,
-        useCacheRefresh: function () {
-          return unsupportedRefresh;
-        },
+        useOptimistic: unsupportedHook,
         useMemoCache: function (size) {
           for (var data = Array(size), i = 0; i < size; i++)
             data[i] = REACT_MEMO_CACHE_SENTINEL;
           return data;
         },
-        use: function (usable) {
-          if (
-            (null !== usable && "object" === typeof usable) ||
-            "function" === typeof usable
-          ) {
-            if ("function" === typeof usable.then) {
-              var index = thenableIndexCounter;
-              thenableIndexCounter += 1;
-              null === thenableState && (thenableState = []);
-              return trackUsedThenable(thenableState, usable, index);
-            }
-            usable.$$typeof === REACT_CONTEXT_TYPE && unsupportedContext();
-          }
-          if (isClientReference(usable)) {
-            if (
-              null != usable.value &&
-              usable.value.$$typeof === REACT_CONTEXT_TYPE
-            )
-              throw Error(
-                "Cannot read a Client Context from a Server Component."
-              );
-            throw Error("Cannot use() an already resolved Client Reference.");
-          }
-          throw Error(
-            "An unsupported type was passed to use(): " + String(usable)
-          );
+        useCacheRefresh: function () {
+          return unsupportedRefresh;
         }
       },
       currentOwner = null,

package/cjs/react-server-dom-webpack-server.node.unbundled.production.js

@@ -525,39 +525,39 @@ function getThenableStateAfterSuspending() {
   return state;
 }
 var HooksDispatcher = {
-  useMemo: function (nextCreate) {
-    return nextCreate();
-  },
+  readContext: unsupportedContext,
+  use: use,
   useCallback: function (callback) {
     return callback;
   },
-  useDebugValue: function () {},
-  useDeferredValue: unsupportedHook,
-  useTransition: unsupportedHook,
-  readContext: unsupportedContext,
   useContext: unsupportedContext,
+  useEffect: unsupportedHook,
+  useImperativeHandle: unsupportedHook,
+  useLayoutEffect: unsupportedHook,
+  useInsertionEffect: unsupportedHook,
+  useMemo: function (nextCreate) {
+    return nextCreate();
+  },
   useReducer: unsupportedHook,
   useRef: unsupportedHook,
   useState: unsupportedHook,
-  useInsertionEffect: unsupportedHook,
-  useLayoutEffect: unsupportedHook,
-  useImperativeHandle: unsupportedHook,
-  useEffect: unsupportedHook,
+  useDebugValue: function () {},
+  useDeferredValue: unsupportedHook,
+  useTransition: unsupportedHook,
+  useSyncExternalStore: unsupportedHook,
   useId: useId,
   useHostTransitionStatus: unsupportedHook,
-  useOptimistic: unsupportedHook,
   useFormState: unsupportedHook,
   useActionState: unsupportedHook,
-  useSyncExternalStore: unsupportedHook,
-  useCacheRefresh: function () {
-    return unsupportedRefresh;
-  },
+  useOptimistic: unsupportedHook,
   useMemoCache: function (size) {
     for (var data = Array(size), i = 0; i < size; i++)
       data[i] = REACT_MEMO_CACHE_SENTINEL;
     return data;
   },
-  use: use
+  useCacheRefresh: function () {
+    return unsupportedRefresh;
+  }
 };
 function unsupportedHook() {
   throw Error("This Hook is not supported in Server Components.");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-webpack",
   "description": "React Server Components bindings for DOM using Webpack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "19.1.0-canary-32b0cad8-20250213",
+  "version": "19.1.0-canary-4632e36a-20250216",
   "keywords": [
     "react"
   ],
@@ -99,8 +99,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "19.1.0-canary-32b0cad8-20250213",
-    "react-dom": "19.1.0-canary-32b0cad8-20250213",
+    "react": "19.1.0-canary-4632e36a-20250216",
+    "react-dom": "19.1.0-canary-4632e36a-20250216",
     "webpack": "^5.59.0"
   },
   "dependencies": {