@matthamlin/react-client 0.0.0-experimental-58ac15cd-20250627 → 0.0.0-experimental-7216c0f0-20250630

package/cjs/react-client-flight.development.js

@@ -1043,6 +1043,44 @@
                     );
                 return;
               }
+            if ("Promise" === typeName) {
+              if ("fulfilled" === value.status) {
+                if (
+                  ((typeName = properties.length),
+                  addValueToProperties(
+                    propertyName,
+                    value.value,
+                    properties,
+                    indent
+                  ),
+                  properties.length > typeName)
+                ) {
+                  properties = properties[typeName];
+                  properties[1] =
+                    "Promise<" + (properties[1] || "Object") + ">";
+                  return;
+                }
+              } else if (
+                "rejected" === value.status &&
+                ((typeName = properties.length),
+                addValueToProperties(
+                  propertyName,
+                  value.reason,
+                  properties,
+                  indent
+                ),
+                properties.length > typeName)
+              ) {
+                properties = properties[typeName];
+                properties[1] = "Rejected Promise<" + properties[1] + ">";
+                return;
+              }
+              properties.push([
+                "\u00a0\u00a0".repeat(indent) + propertyName,
+                "Promise"
+              ]);
+              return;
+            }
             "Object" === typeName &&
               (propKey = Object.getPrototypeOf(value)) &&
               "function" === typeof propKey.constructor &&
@@ -1264,17 +1302,64 @@
       return new ReactPromise("rejected", null, error);
     }
     function wakeChunk(listeners, value) {
-      for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
+      for (var i = 0; i < listeners.length; i++) {
+        var listener = listeners[i];
+        "function" === typeof listener
+          ? listener(value)
+          : fulfillReference(listener, value);
+      }
+    }
+    function rejectChunk(listeners, error) {
+      for (var i = 0; i < listeners.length; i++) {
+        var listener = listeners[i];
+        "function" === typeof listener
+          ? listener(error)
+          : rejectReference(listener, error);
+      }
+    }
+    function resolveBlockedCycle(resolvedChunk, reference) {
+      var referencedChunk = reference.handler.chunk;
+      if (null === referencedChunk) return null;
+      if (referencedChunk === resolvedChunk) return reference.handler;
+      reference = referencedChunk.value;
+      if (null !== reference)
+        for (
+          referencedChunk = 0;
+          referencedChunk < reference.length;
+          referencedChunk++
+        ) {
+          var listener = reference[referencedChunk];
+          if (
+            "function" !== typeof listener &&
+            ((listener = resolveBlockedCycle(resolvedChunk, listener)),
+            null !== listener)
+          )
+            return listener;
+        }
+      return null;
     }
     function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       switch (chunk.status) {
         case "fulfilled":
           wakeChunk(resolveListeners, chunk.value);
           break;
-        case "pending":
         case "blocked":
+          for (var i = 0; i < resolveListeners.length; i++) {
+            var listener = resolveListeners[i];
+            if ("function" !== typeof listener) {
+              var cyclicHandler = resolveBlockedCycle(chunk, listener);
+              null !== cyclicHandler &&
+                (fulfillReference(listener, cyclicHandler.value),
+                resolveListeners.splice(i, 1),
+                i--,
+                null !== rejectListeners &&
+                  ((listener = rejectListeners.indexOf(listener)),
+                  -1 !== listener && rejectListeners.splice(listener, 1)));
+            }
+          }
+        case "pending":
           if (chunk.value)
-            for (var i = 0; i < resolveListeners.length; i++)
+            for (i = 0; i < resolveListeners.length; i++)
               chunk.value.push(resolveListeners[i]);
           else chunk.value = resolveListeners;
           if (chunk.reason) {
@@ -1288,7 +1373,7 @@
           } else chunk.reason = rejectListeners;
           break;
         case "rejected":
-          rejectListeners && wakeChunk(rejectListeners, chunk.reason);
+          rejectListeners && rejectChunk(rejectListeners, chunk.reason);
       }
     }
     function triggerErrorOnChunk(chunk, error) {
@@ -1298,7 +1383,7 @@
         var listeners = chunk.reason;
         chunk.status = "rejected";
         chunk.reason = error;
-        null !== listeners && wakeChunk(listeners, error);
+        null !== listeners && rejectChunk(listeners, error);
       }
     }
     function createResolvedIteratorResultChunk(response, value, done) {
@@ -1394,14 +1479,15 @@
       var debugChannel = response._debugChannel;
       void 0 !== debugChannel &&
         (debugChannel(""), (response._debugChannel = void 0));
-      markAllTracksInOrder();
-      flushComponentPerformance(
-        response,
-        getChunk(response, 0),
-        0,
-        -Infinity,
-        -Infinity
-      );
+      response._replayConsole &&
+        (markAllTracksInOrder(),
+        flushComponentPerformance(
+          response,
+          getChunk(response, 0),
+          0,
+          -Infinity,
+          -Infinity
+        ));
     }
     function nullRefGetter() {
       return null;
@@ -1481,6 +1567,115 @@
         chunks.set(id, chunk));
       return chunk;
     }
+    function fulfillReference(reference, value) {
+      for (
+        var response = reference.response,
+          handler = reference.handler,
+          parentObject = reference.parentObject,
+          key = reference.key,
+          map = reference.map,
+          path = reference.path,
+          i = 1;
+        i < path.length;
+        i++
+      ) {
+        for (; value.$$typeof === REACT_LAZY_TYPE; )
+          if (((value = value._payload), value === handler.chunk))
+            value = handler.value;
+          else {
+            switch (value.status) {
+              case "resolved_model":
+                initializeModelChunk(value);
+                break;
+              case "resolved_module":
+                initializeModuleChunk(value);
+            }
+            switch (value.status) {
+              case "fulfilled":
+                value = value.value;
+                continue;
+              case "blocked":
+                var cyclicHandler = resolveBlockedCycle(value, reference);
+                if (null !== cyclicHandler) {
+                  value = cyclicHandler.value;
+                  continue;
+                }
+              case "pending":
+                path.splice(0, i - 1);
+                null === value.value
+                  ? (value.value = [reference])
+                  : value.value.push(reference);
+                null === value.reason
+                  ? (value.reason = [reference])
+                  : value.reason.push(reference);
+                return;
+              case "halted":
+                return;
+              default:
+                rejectReference(reference, value.reason);
+                return;
+            }
+          }
+        value = value[path[i]];
+      }
+      reference = map(response, value, parentObject, key);
+      parentObject[key] = reference;
+      "" === key && null === handler.value && (handler.value = reference);
+      if (
+        parentObject[0] === REACT_ELEMENT_TYPE &&
+        "object" === typeof handler.value &&
+        null !== handler.value &&
+        handler.value.$$typeof === REACT_ELEMENT_TYPE
+      )
+        switch (((parentObject = handler.value), key)) {
+          case "3":
+            parentObject.props = reference;
+            break;
+          case "4":
+            parentObject._owner = reference;
+            break;
+          case "5":
+            parentObject._debugStack = reference;
+        }
+      handler.deps--;
+      0 === handler.deps &&
+        ((key = handler.chunk),
+        null !== key &&
+          "blocked" === key.status &&
+          ((parentObject = key.value),
+          (key.status = "fulfilled"),
+          (key.value = handler.value),
+          null !== parentObject && wakeChunk(parentObject, handler.value)));
+    }
+    function rejectReference(reference, error) {
+      var handler = reference.handler;
+      if (
+        !handler.errored &&
+        ((reference = handler.value),
+        (handler.errored = !0),
+        (handler.value = error),
+        (handler = handler.chunk),
+        null !== handler && "blocked" === handler.status)
+      ) {
+        if (
+          "object" === typeof reference &&
+          null !== reference &&
+          reference.$$typeof === REACT_ELEMENT_TYPE
+        ) {
+          var erroredComponent = {
+            name: getComponentNameFromType(reference.type) || "",
+            owner: reference._owner
+          };
+          erroredComponent.debugStack = reference._debugStack;
+          supportsCreateTask &&
+            (erroredComponent.debugTask = reference._debugTask);
+          (handler._debugInfo || (handler._debugInfo = [])).push(
+            erroredComponent
+          );
+        }
+        triggerErrorOnChunk(handler, error);
+      }
+    }
     function waitForReference(
       referencedChunk,
       parentObject,
@@ -1489,75 +1684,6 @@
       map,
       path
     ) {
-      function fulfill(value) {
-        for (var i = 1; i < path.length; i++) {
-          for (; value.$$typeof === REACT_LAZY_TYPE; )
-            if (((value = value._payload), value === handler.chunk))
-              value = handler.value;
-            else if ("fulfilled" === value.status) value = value.value;
-            else {
-              path.splice(0, i - 1);
-              value.then(fulfill, reject);
-              return;
-            }
-          value = value[path[i]];
-        }
-        i = map(response, value, parentObject, key);
-        parentObject[key] = i;
-        "" === key && null === handler.value && (handler.value = i);
-        if (
-          parentObject[0] === REACT_ELEMENT_TYPE &&
-          "object" === typeof handler.value &&
-          null !== handler.value &&
-          handler.value.$$typeof === REACT_ELEMENT_TYPE
-        )
-          switch (((value = handler.value), key)) {
-            case "3":
-              value.props = i;
-              break;
-            case "4":
-              value._owner = i;
-              break;
-            case "5":
-              value._debugStack = i;
-          }
-        handler.deps--;
-        0 === handler.deps &&
-          ((i = handler.chunk),
-          null !== i &&
-            "blocked" === i.status &&
-            ((value = i.value),
-            (i.status = "fulfilled"),
-            (i.value = handler.value),
-            null !== value && wakeChunk(value, handler.value)));
-      }
-      function reject(error) {
-        if (!handler.errored) {
-          var blockedValue = handler.value;
-          handler.errored = !0;
-          handler.value = error;
-          var chunk = handler.chunk;
-          if (null !== chunk && "blocked" === chunk.status) {
-            if (
-              "object" === typeof blockedValue &&
-              null !== blockedValue &&
-              blockedValue.$$typeof === REACT_ELEMENT_TYPE
-            ) {
-              var erroredComponent = {
-                name: getComponentNameFromType(blockedValue.type) || "",
-                owner: blockedValue._owner
-              };
-              erroredComponent.debugStack = blockedValue._debugStack;
-              supportsCreateTask &&
-                (erroredComponent.debugTask = blockedValue._debugTask);
-              (chunk._debugInfo || (chunk._debugInfo = [])).push(
-                erroredComponent
-              );
-            }
-            triggerErrorOnChunk(chunk, error);
-          }
-        }
-      }
       if (initializingHandler) {
         var handler = initializingHandler;
         handler.deps++;
@@ -1569,8 +1695,20 @@
           deps: 1,
           errored: !1
         };
-      fulfill.isReactInternalListener = !0;
-      referencedChunk.then(fulfill, reject);
+      parentObject = {
+        response: response,
+        handler: handler,
+        parentObject: parentObject,
+        key: key,
+        map: map,
+        path: path
+      };
+      null === referencedChunk.value
+        ? (referencedChunk.value = [parentObject])
+        : referencedChunk.value.push(parentObject);
+      null === referencedChunk.reason
+        ? (referencedChunk.reason = [parentObject])
+        : referencedChunk.reason.push(parentObject);
       return null;
     }
     function loadServerReference(response, metaData, parentObject, key) {
@@ -1699,18 +1837,58 @@
       switch (id.status) {
         case "fulfilled":
           for (var value = id.value, i = 1; i < reference.length; i++) {
-            for (; value.$$typeof === REACT_LAZY_TYPE; )
-              if (((value = value._payload), "fulfilled" === value.status))
-                value = value.value;
-              else
-                return waitForReference(
-                  value,
-                  parentObject,
-                  key,
-                  response,
-                  map,
-                  reference.slice(i - 1)
-                );
+            for (; value.$$typeof === REACT_LAZY_TYPE; ) {
+              value = value._payload;
+              switch (value.status) {
+                case "resolved_model":
+                  initializeModelChunk(value);
+                  break;
+                case "resolved_module":
+                  initializeModuleChunk(value);
+              }
+              switch (value.status) {
+                case "fulfilled":
+                  value = value.value;
+                  break;
+                case "blocked":
+                case "pending":
+                  return waitForReference(
+                    value,
+                    parentObject,
+                    key,
+                    response,
+                    map,
+                    reference.slice(i - 1)
+                  );
+                case "halted":
+                  return (
+                    initializingHandler
+                      ? ((response = initializingHandler), response.deps++)
+                      : (initializingHandler = {
+                          parent: null,
+                          chunk: null,
+                          value: null,
+                          deps: 1,
+                          errored: !1
+                        }),
+                    null
+                  );
+                default:
+                  return (
+                    initializingHandler
+                      ? ((initializingHandler.errored = !0),
+                        (initializingHandler.value = value.reason))
+                      : (initializingHandler = {
+                          parent: null,
+                          chunk: null,
+                          value: value.reason,
+                          deps: 0,
+                          errored: !0
+                        }),
+                    null
+                  );
+              }
+            }
             value = value[reference[i]];
           }
           response = map(response, value, parentObject, key);
@@ -1730,7 +1908,6 @@
           return response;
         case "pending":
         case "blocked":
-        case "halted":
           return waitForReference(
             id,
             parentObject,
@@ -1739,6 +1916,19 @@
             map,
             reference
           );
+        case "halted":
+          return (
+            initializingHandler
+              ? ((response = initializingHandler), response.deps++)
+              : (initializingHandler = {
+                  parent: null,
+                  chunk: null,
+                  value: null,
+                  deps: 1,
+                  errored: !1
+                }),
+            null
+          );
         default:
           return (
             initializingHandler
@@ -2019,7 +2209,7 @@
       this._debugChannel = debugChannel;
       this._replayConsole = replayConsole;
       this._rootEnvironmentName = environmentName;
-      markAllTracksInOrder();
+      replayConsole && markAllTracksInOrder();
       this._fromJSON = createFromJSONCallback(this);
     }
     function resolveDebugHalt(response, id) {
@@ -2135,8 +2325,8 @@
                 (previousBlockedChunk = chunk));
           } else {
             chunk = previousBlockedChunk;
-            var _chunk3 = createPendingChunk();
-            _chunk3.then(
+            var _chunk2 = createPendingChunk();
+            _chunk2.then(
               function (v) {
                 return controller.enqueue(v);
               },
@@ -2144,10 +2334,10 @@
                 return controller.error(e);
               }
             );
-            previousBlockedChunk = _chunk3;
+            previousBlockedChunk = _chunk2;
             chunk.then(function () {
-              previousBlockedChunk === _chunk3 && (previousBlockedChunk = null);
-              resolveModelChunk(response, _chunk3, json);
+              previousBlockedChunk === _chunk2 && (previousBlockedChunk = null);
+              resolveModelChunk(response, _chunk2, json);
             });
           }
         },
@@ -2632,23 +2822,25 @@
         initializeFakeStack(response, ioInfo));
       ioInfo.start += response._timeOrigin;
       ioInfo.end += response._timeOrigin;
-      response = response._rootEnvironmentName;
-      var promise = ioInfo.value;
-      if (promise)
-        switch (promise.status) {
-          case "fulfilled":
-            logIOInfo(ioInfo, response, promise.value);
-            break;
-          case "rejected":
-            logIOInfoErrored(ioInfo, response, promise.reason);
-            break;
-          default:
-            promise.then(
-              logIOInfo.bind(null, ioInfo, response),
-              logIOInfoErrored.bind(null, ioInfo, response)
-            );
-        }
-      else logIOInfo(ioInfo, response, void 0);
+      if (response._replayConsole) {
+        response = response._rootEnvironmentName;
+        var promise = ioInfo.value;
+        if (promise)
+          switch (promise.status) {
+            case "fulfilled":
+              logIOInfo(ioInfo, response, promise.value);
+              break;
+            case "rejected":
+              logIOInfoErrored(ioInfo, response, promise.reason);
+              break;
+            default:
+              promise.then(
+                logIOInfo.bind(null, ioInfo, response),
+                logIOInfoErrored.bind(null, ioInfo, response)
+              );
+          }
+        else logIOInfo(ioInfo, response, void 0);
+      }
     }
     function resolveIOInfo(response, id, model) {
       var chunks = response._chunks,
@@ -2676,8 +2868,8 @@
       )
         byteLength += buffer[i].byteLength;
       byteLength = new Uint8Array(byteLength);
-      for (var _i2 = (i = 0); _i2 < l; _i2++) {
-        var chunk = buffer[_i2];
+      for (var _i3 = (i = 0); _i3 < l; _i3++) {
+        var chunk = buffer[_i3];
         byteLength.set(chunk, i);
         i += chunk.byteLength;
       }
@@ -2785,10 +2977,10 @@
       root._children = trackIdx;
       componentInfo = -Infinity;
       info = trackIdx$jscomp$1;
-      for (var _i4 = 0; _i4 < entryName.length; _i4++) {
+      for (var _i5 = 0; _i5 < entryName.length; _i5++) {
         var childResult = flushComponentPerformance(
           response$jscomp$0,
-          entryName[_i4],
+          entryName[_i5],
           info,
           trackTime,
           parentEndTime
@@ -2803,7 +2995,7 @@
       if (previousEndTime)
         for (
           childResult = 0,
-            _i4 = !0,
+            _i5 = !0,
             info = parentEndTime = -1,
             entryName = previousEndTime.length - 1;
           0 <= entryName;
@@ -2827,17 +3019,17 @@
                     componentEndTime = childResult,
                     childrenEndTime = componentInfo;
                   if (
-                    _i4 &&
+                    _i5 &&
                     "rejected" === root.status &&
                     root.reason !== response._closedReason
                   )
-                    (_i4 = componentInfo$jscomp$0),
+                    (_i5 = componentInfo$jscomp$0),
                       (childResult = trackIdx$jscomp$0),
                       (componentEndTime = childrenEndTime),
                       (childrenEndTime = root.reason),
                       supportsUserTiming &&
-                        ((trackIdx$jscomp$0 = _i4.env),
-                        (componentInfo$jscomp$0 = _i4.name),
+                        ((trackIdx$jscomp$0 = _i5.env),
+                        (componentInfo$jscomp$0 = _i5.name),
                         (response =
                           trackIdx$jscomp$0 === response._rootEnvironmentName ||
                           void 0 === trackIdx$jscomp$0
@@ -2856,15 +3048,15 @@
                               : String(childrenEndTime)
                           ]
                         ]),
-                        null != _i4.key &&
+                        null != _i5.key &&
                           addValueToProperties(
                             "key",
-                            _i4.key,
+                            _i5.key,
                             childrenEndTime,
                             0
                           ),
-                        null != _i4.props &&
-                          addObjectToProperties(_i4.props, childrenEndTime, 0),
+                        null != _i5.props &&
+                          addObjectToProperties(_i5.props, childrenEndTime, 0),
                         performance.measure(response, {
                           start: 0 > startTime ? 0 : startTime,
                           end: componentEndTime,
@@ -2879,14 +3071,14 @@
                           }
                         }));
                   else if (
-                    ((_i4 = componentInfo$jscomp$0),
+                    ((_i5 = componentInfo$jscomp$0),
                     (childResult = trackIdx$jscomp$0),
                     supportsUserTiming &&
                       0 <= childrenEndTime &&
                       10 > childResult)
                   ) {
-                    trackIdx$jscomp$0 = _i4.env;
-                    componentInfo$jscomp$0 = _i4.name;
+                    trackIdx$jscomp$0 = _i5.env;
+                    componentInfo$jscomp$0 = _i5.name;
                     var isPrimaryEnv =
                       trackIdx$jscomp$0 === response._rootEnvironmentName;
                     response = componentEndTime - startTime;
@@ -2911,18 +3103,18 @@
                           " [" +
                           trackIdx$jscomp$0 +
                           "]";
-                    (trackIdx$jscomp$0 = _i4.debugTask)
+                    (trackIdx$jscomp$0 = _i5.debugTask)
                       ? ((componentInfo$jscomp$0 = []),
-                        null != _i4.key &&
+                        null != _i5.key &&
                           addValueToProperties(
                             "key",
-                            _i4.key,
+                            _i5.key,
                             componentInfo$jscomp$0,
                             0
                           ),
-                        null != _i4.props &&
+                        null != _i5.props &&
                           addObjectToProperties(
-                            _i4.props,
+                            _i5.props,
                             componentInfo$jscomp$0,
                             0
                           ),
@@ -2955,7 +3147,7 @@
                   }
                   childResult = trackTime;
                   trackIdx.component = candidateInfo;
-                  _i4 = !1;
+                  _i5 = !1;
                 } else if (candidateInfo.awaited)
                   if (
                     (parentEndTime > componentInfo &&
@@ -3069,10 +3261,10 @@
                   "string" === typeof candidateInfo.name
                     ? (childResult > componentInfo &&
                         (componentInfo = childResult),
-                      (_i4 = candidateInfo),
+                      (_i5 = candidateInfo),
                       (componentEndTime =
                         response$jscomp$0._rootEnvironmentName),
-                      (childResult = _i4),
+                      (childResult = _i5),
                       (candidateInfo = trackIdx$jscomp$1),
                       (response = trackTime),
                       (startTime = componentInfo),
@@ -3117,8 +3309,8 @@
                           }
                         })),
                       (childResult = trackTime),
-                      (trackIdx.component = _i4),
-                      (_i4 = !1))
+                      (trackIdx.component = _i5),
+                      (_i5 = !1))
                     : candidateInfo.awaited &&
                       ((componentEndTime = candidateInfo),
                       (childrenEndTime =
@@ -3314,6 +3506,7 @@
         if ("object" === typeof value && null !== value) {
           if (value[0] === REACT_ELEMENT_TYPE)
             b: {
+              var owner = value[4];
               key = value[5];
               var validated = value[6];
               value = {
@@ -3321,7 +3514,7 @@
                 type: value[1],
                 key: value[2],
                 props: value[3],
-                _owner: value[4]
+                _owner: void 0 === owner ? null : owner
               };
               Object.defineProperty(value, "ref", {
                 enumerable: !1,
@@ -3344,7 +3537,7 @@
                 configurable: !1,
                 enumerable: !1,
                 writable: !0,
-                value: key
+                value: void 0 === key ? null : key
               });
               Object.defineProperty(value, "_debugTask", {
                 configurable: !1,
@@ -3461,38 +3654,36 @@
         case "resolved_module":
           initializeModuleChunk(this);
       }
-      if ("function" !== typeof resolve || !resolve.isReactInternalListener) {
-        var resolveCallback = resolve,
-          rejectCallback = reject,
-          wrapperPromise = new Promise(function (res, rej) {
-            resolve = function (value) {
-              wrapperPromise._debugInfo = _this._debugInfo;
-              res(value);
-            };
-            reject = function (reason) {
-              wrapperPromise._debugInfo = _this._debugInfo;
-              rej(reason);
-            };
-          });
-        wrapperPromise.then(resolveCallback, rejectCallback);
-      }
+      var resolveCallback = resolve,
+        rejectCallback = reject,
+        wrapperPromise = new Promise(function (res, rej) {
+          resolve = function (value) {
+            wrapperPromise._debugInfo = _this._debugInfo;
+            res(value);
+          };
+          reject = function (reason) {
+            wrapperPromise._debugInfo = _this._debugInfo;
+            rej(reason);
+          };
+        });
+      wrapperPromise.then(resolveCallback, rejectCallback);
       switch (this.status) {
         case "fulfilled":
-          resolve(this.value);
+          "function" === typeof resolve && resolve(this.value);
           break;
         case "pending":
         case "blocked":
-          resolve &&
+          "function" === typeof resolve &&
             (null === this.value && (this.value = []),
             this.value.push(resolve));
-          reject &&
+          "function" === typeof reject &&
             (null === this.reason && (this.reason = []),
             this.reason.push(reject));
           break;
         case "halted":
           break;
         default:
-          reject && reject(this.reason);
+          "function" === typeof reject && reject(this.reason);
       }
     };
     var initializingHandler = null,
@@ -3597,7 +3788,7 @@
         version: rendererVersion,
         rendererPackageName: rendererPackageName,
         currentDispatcherRef: ReactSharedInternals,
-        reconcilerVersion: "19.2.0-experimental-58ac15cd-20250627",
+        reconcilerVersion: "19.2.0-experimental-7216c0f0-20250630",
         getCurrentComponentInfo: getCurrentOwnerInDEV
       };
       if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)

package/cjs/react-client-flight.production.js

@@ -585,17 +585,64 @@ module.exports = function ($$$config) {
     return new ReactPromise("rejected", null, error);
   }
   function wakeChunk(listeners, value) {
-    for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      "function" === typeof listener
+        ? listener(value)
+        : fulfillReference(listener, value);
+    }
+  }
+  function rejectChunk(listeners, error) {
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      "function" === typeof listener
+        ? listener(error)
+        : rejectReference(listener, error);
+    }
+  }
+  function resolveBlockedCycle(resolvedChunk, reference) {
+    var referencedChunk = reference.handler.chunk;
+    if (null === referencedChunk) return null;
+    if (referencedChunk === resolvedChunk) return reference.handler;
+    reference = referencedChunk.value;
+    if (null !== reference)
+      for (
+        referencedChunk = 0;
+        referencedChunk < reference.length;
+        referencedChunk++
+      ) {
+        var listener = reference[referencedChunk];
+        if (
+          "function" !== typeof listener &&
+          ((listener = resolveBlockedCycle(resolvedChunk, listener)),
+          null !== listener)
+        )
+          return listener;
+      }
+    return null;
   }
   function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
     switch (chunk.status) {
       case "fulfilled":
         wakeChunk(resolveListeners, chunk.value);
         break;
-      case "pending":
       case "blocked":
+        for (var i = 0; i < resolveListeners.length; i++) {
+          var listener = resolveListeners[i];
+          if ("function" !== typeof listener) {
+            var cyclicHandler = resolveBlockedCycle(chunk, listener);
+            null !== cyclicHandler &&
+              (fulfillReference(listener, cyclicHandler.value),
+              resolveListeners.splice(i, 1),
+              i--,
+              null !== rejectListeners &&
+                ((listener = rejectListeners.indexOf(listener)),
+                -1 !== listener && rejectListeners.splice(listener, 1)));
+          }
+        }
+      case "pending":
         if (chunk.value)
-          for (var i = 0; i < resolveListeners.length; i++)
+          for (i = 0; i < resolveListeners.length; i++)
             chunk.value.push(resolveListeners[i]);
         else chunk.value = resolveListeners;
         if (chunk.reason) {
@@ -609,7 +656,7 @@ module.exports = function ($$$config) {
         } else chunk.reason = rejectListeners;
         break;
       case "rejected":
-        rejectListeners && wakeChunk(rejectListeners, chunk.reason);
+        rejectListeners && rejectChunk(rejectListeners, chunk.reason);
     }
   }
   function triggerErrorOnChunk(chunk, error) {
@@ -619,7 +666,7 @@ module.exports = function ($$$config) {
       var listeners = chunk.reason;
       chunk.status = "rejected";
       chunk.reason = error;
-      null !== listeners && wakeChunk(listeners, error);
+      null !== listeners && rejectChunk(listeners, error);
     }
   }
   function createResolvedIteratorResultChunk(response, value, done) {
@@ -720,6 +767,90 @@ module.exports = function ($$$config) {
       chunks.set(id, chunk));
     return chunk;
   }
+  function fulfillReference(reference, value) {
+    for (
+      var response = reference.response,
+        handler = reference.handler,
+        parentObject = reference.parentObject,
+        key = reference.key,
+        map = reference.map,
+        path = reference.path,
+        i = 1;
+      i < path.length;
+      i++
+    ) {
+      for (; value.$$typeof === REACT_LAZY_TYPE; )
+        if (((value = value._payload), value === handler.chunk))
+          value = handler.value;
+        else {
+          switch (value.status) {
+            case "resolved_model":
+              initializeModelChunk(value);
+              break;
+            case "resolved_module":
+              initializeModuleChunk(value);
+          }
+          switch (value.status) {
+            case "fulfilled":
+              value = value.value;
+              continue;
+            case "blocked":
+              var cyclicHandler = resolveBlockedCycle(value, reference);
+              if (null !== cyclicHandler) {
+                value = cyclicHandler.value;
+                continue;
+              }
+            case "pending":
+              path.splice(0, i - 1);
+              null === value.value
+                ? (value.value = [reference])
+                : value.value.push(reference);
+              null === value.reason
+                ? (value.reason = [reference])
+                : value.reason.push(reference);
+              return;
+            case "halted":
+              return;
+            default:
+              rejectReference(reference, value.reason);
+              return;
+          }
+        }
+      value = value[path[i]];
+    }
+    reference = map(response, value, parentObject, key);
+    parentObject[key] = reference;
+    "" === key && null === handler.value && (handler.value = reference);
+    if (
+      parentObject[0] === REACT_ELEMENT_TYPE &&
+      "object" === typeof handler.value &&
+      null !== handler.value &&
+      handler.value.$$typeof === REACT_ELEMENT_TYPE
+    )
+      switch (((parentObject = handler.value), key)) {
+        case "3":
+          parentObject.props = reference;
+      }
+    handler.deps--;
+    0 === handler.deps &&
+      ((key = handler.chunk),
+      null !== key &&
+        "blocked" === key.status &&
+        ((parentObject = key.value),
+        (key.status = "fulfilled"),
+        (key.value = handler.value),
+        null !== parentObject && wakeChunk(parentObject, handler.value)));
+  }
+  function rejectReference(reference, error) {
+    reference = reference.handler;
+    reference.errored ||
+      ((reference.errored = !0),
+      (reference.value = error),
+      (reference = reference.chunk),
+      null !== reference &&
+        "blocked" === reference.status &&
+        triggerErrorOnChunk(reference, error));
+  }
   function waitForReference(
     referencedChunk,
     parentObject,
@@ -728,52 +859,6 @@ module.exports = function ($$$config) {
     map,
     path
   ) {
-    function fulfill(value) {
-      for (var i = 1; i < path.length; i++) {
-        for (; value.$$typeof === REACT_LAZY_TYPE; )
-          if (((value = value._payload), value === handler.chunk))
-            value = handler.value;
-          else if ("fulfilled" === value.status) value = value.value;
-          else {
-            path.splice(0, i - 1);
-            value.then(fulfill, reject);
-            return;
-          }
-        value = value[path[i]];
-      }
-      i = map(response, value, parentObject, key);
-      parentObject[key] = i;
-      "" === key && null === handler.value && (handler.value = i);
-      if (
-        parentObject[0] === REACT_ELEMENT_TYPE &&
-        "object" === typeof handler.value &&
-        null !== handler.value &&
-        handler.value.$$typeof === REACT_ELEMENT_TYPE
-      )
-        switch (((value = handler.value), key)) {
-          case "3":
-            value.props = i;
-        }
-      handler.deps--;
-      0 === handler.deps &&
-        ((i = handler.chunk),
-        null !== i &&
-          "blocked" === i.status &&
-          ((value = i.value),
-          (i.status = "fulfilled"),
-          (i.value = handler.value),
-          null !== value && wakeChunk(value, handler.value)));
-    }
-    function reject(error) {
-      if (!handler.errored) {
-        handler.errored = !0;
-        handler.value = error;
-        var chunk = handler.chunk;
-        null !== chunk &&
-          "blocked" === chunk.status &&
-          triggerErrorOnChunk(chunk, error);
-      }
-    }
     if (initializingHandler) {
       var handler = initializingHandler;
       handler.deps++;
@@ -785,7 +870,20 @@ module.exports = function ($$$config) {
         deps: 1,
         errored: !1
       };
-    referencedChunk.then(fulfill, reject);
+    parentObject = {
+      response: response,
+      handler: handler,
+      parentObject: parentObject,
+      key: key,
+      map: map,
+      path: path
+    };
+    null === referencedChunk.value
+      ? (referencedChunk.value = [parentObject])
+      : referencedChunk.value.push(parentObject);
+    null === referencedChunk.reason
+      ? (referencedChunk.reason = [parentObject])
+      : referencedChunk.reason.push(parentObject);
     return null;
   }
   function loadServerReference(response, metaData, parentObject, key) {
@@ -889,24 +987,63 @@ module.exports = function ($$$config) {
       case "fulfilled":
         var value = id.value;
         for (id = 1; id < reference.length; id++) {
-          for (; value.$$typeof === REACT_LAZY_TYPE; )
-            if (((value = value._payload), "fulfilled" === value.status))
-              value = value.value;
-            else
-              return waitForReference(
-                value,
-                parentObject,
-                key,
-                response,
-                map,
-                reference.slice(id - 1)
-              );
+          for (; value.$$typeof === REACT_LAZY_TYPE; ) {
+            value = value._payload;
+            switch (value.status) {
+              case "resolved_model":
+                initializeModelChunk(value);
+                break;
+              case "resolved_module":
+                initializeModuleChunk(value);
+            }
+            switch (value.status) {
+              case "fulfilled":
+                value = value.value;
+                break;
+              case "blocked":
+              case "pending":
+                return waitForReference(
+                  value,
+                  parentObject,
+                  key,
+                  response,
+                  map,
+                  reference.slice(id - 1)
+                );
+              case "halted":
+                return (
+                  initializingHandler
+                    ? ((response = initializingHandler), response.deps++)
+                    : (initializingHandler = {
+                        parent: null,
+                        chunk: null,
+                        value: null,
+                        deps: 1,
+                        errored: !1
+                      }),
+                  null
+                );
+              default:
+                return (
+                  initializingHandler
+                    ? ((initializingHandler.errored = !0),
+                      (initializingHandler.value = value.reason))
+                    : (initializingHandler = {
+                        parent: null,
+                        chunk: null,
+                        value: value.reason,
+                        deps: 0,
+                        errored: !0
+                      }),
+                  null
+                );
+            }
+          }
           value = value[reference[id]];
         }
         return map(response, value, parentObject, key);
       case "pending":
       case "blocked":
-      case "halted":
         return waitForReference(
           id,
           parentObject,
@@ -915,6 +1052,19 @@ module.exports = function ($$$config) {
           map,
           reference
         );
+      case "halted":
+        return (
+          initializingHandler
+            ? ((response = initializingHandler), response.deps++)
+            : (initializingHandler = {
+                parent: null,
+                chunk: null,
+                value: null,
+                deps: 1,
+                errored: !1
+              }),
+          null
+        );
       default:
         return (
           initializingHandler
@@ -1171,8 +1321,8 @@ module.exports = function ($$$config) {
               (previousBlockedChunk = chunk));
         } else {
           chunk = previousBlockedChunk;
-          var chunk$30 = new ReactPromise("pending", null, null);
-          chunk$30.then(
+          var chunk$31 = new ReactPromise("pending", null, null);
+          chunk$31.then(
             function (v) {
               return controller.enqueue(v);
             },
@@ -1180,10 +1330,10 @@ module.exports = function ($$$config) {
               return controller.error(e);
             }
           );
-          previousBlockedChunk = chunk$30;
+          previousBlockedChunk = chunk$31;
           chunk.then(function () {
-            previousBlockedChunk === chunk$30 && (previousBlockedChunk = null);
-            resolveModelChunk(response, chunk$30, json);
+            previousBlockedChunk === chunk$31 && (previousBlockedChunk = null);
+            resolveModelChunk(response, chunk$31, json);
           });
         }
       },
@@ -1324,8 +1474,8 @@ module.exports = function ($$$config) {
     )
       byteLength += buffer[i].byteLength;
     byteLength = new Uint8Array(byteLength);
-    for (var i$31 = (i = 0); i$31 < l; i$31++) {
-      var chunk = buffer[i$31];
+    for (var i$32 = (i = 0); i$32 < l; i$32++) {
+      var chunk = buffer[i$32];
       byteLength.set(chunk, i);
       i += chunk.byteLength;
     }
@@ -1552,20 +1702,20 @@ module.exports = function ($$$config) {
     }
     switch (this.status) {
       case "fulfilled":
-        resolve(this.value);
+        "function" === typeof resolve && resolve(this.value);
         break;
       case "pending":
       case "blocked":
-        resolve &&
+        "function" === typeof resolve &&
           (null === this.value && (this.value = []), this.value.push(resolve));
-        reject &&
+        "function" === typeof reject &&
           (null === this.reason && (this.reason = []),
           this.reason.push(reject));
         break;
       case "halted":
         break;
       default:
-        reject && reject(this.reason);
+        "function" === typeof reject && reject(this.reason);
     }
   };
   var initializingHandler = null;
@@ -1600,7 +1750,7 @@ module.exports = function ($$$config) {
       version: rendererVersion,
       rendererPackageName: rendererPackageName,
       currentDispatcherRef: ReactSharedInternals,
-      reconcilerVersion: "19.2.0-experimental-58ac15cd-20250627",
+      reconcilerVersion: "19.2.0-experimental-7216c0f0-20250630",
       getCurrentComponentInfo: getCurrentOwnerInDEV
     };
     if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@matthamlin/react-client",
   "description": "React package for consuming streaming models.",
-  "version": "0.0.0-experimental-58ac15cd-20250627",
+  "version": "0.0.0-experimental-7216c0f0-20250630",
   "keywords": [
     "react"
   ],
@@ -23,6 +23,6 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "0.0.0-experimental-58ac15cd-20250627"
+    "react": "0.0.0-experimental-7216c0f0-20250630"
   }
 }