react-markup 0.0.0-experimental-372ec00c-20241209 → 0.0.0-experimental-7130d0c6-20241212

package/cjs/react-markup.react-server.development.js

@@ -823,8 +823,10 @@
           ? defaultFilterStackFrame
           : filterStackFrame;
       this.didWarnForKey = null;
-      type = createTask(this, model, null, !1, abortSet, null, null, null);
-      pingedTasks.push(type);
+      type = this.timeOrigin = performance.now();
+      emitTimeOriginChunk(this, type + performance.timeOrigin);
+      model = createTask(this, model, null, !1, abortSet, null, null, null);
+      pingedTasks.push(model);
     }
     function noop$3() {}
     function serializeThenable(request, task, thenable) {
@@ -848,21 +850,7 @@
             newTask.id
           );
         case "rejected":
-          task = thenable.reason;
-          if (
-            "object" === typeof task &&
-            null !== task &&
-            task.$$typeof === REACT_POSTPONE_TYPE
-          )
-            logPostpone$1(request, task.message, newTask),
-              emitPostponeChunk(request, newTask.id, task);
-          else {
-            var digest = logRecoverableError$1(request, task, null);
-            emitErrorChunk(request, newTask.id, digest, task);
-          }
-          newTask.status = ERRORED$2;
-          request.abortableTasks.delete(newTask);
-          return newTask.id;
+          return erroredTask$1(request, newTask, thenable.reason), newTask.id;
         default:
           if (request.status === ABORTING$1)
             return (
@@ -894,24 +882,11 @@
           pingTask$1(request, newTask);
         },
         function (reason) {
-          if (newTask.status === PENDING$3) {
-            if (
-              "object" === typeof reason &&
-              null !== reason &&
-              reason.$$typeof === REACT_POSTPONE_TYPE
-            )
-              logPostpone$1(request, reason.message, newTask),
-                emitPostponeChunk(request, newTask.id, reason);
-            else {
-              var _digest = logRecoverableError$1(request, reason, newTask);
-              emitErrorChunk(request, newTask.id, _digest, reason);
-            }
-            newTask.status = ERRORED$2;
-            request.abortableTasks.delete(newTask);
-            enqueueFlush(request);
-          }
+          newTask.status === PENDING$3 &&
+            (erroredTask$1(request, newTask, reason), enqueueFlush(request));
         }
       );
+      newTask.timed = !0;
       return newTask.id;
     }
     function serializeReadableStream(request, task, stream) {
@@ -935,38 +910,22 @@
             }
       }
       function error(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortStream);
-          var digest = logRecoverableError$1(request, reason, streamTask);
-          emitErrorChunk(request, streamTask.id, digest, reason);
-          enqueueFlush(request);
-          reader.cancel(reason).then(error, error);
-        }
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortStream),
+          erroredTask$1(request, streamTask, reason),
+          enqueueFlush(request),
+          reader.cancel(reason).then(error, error));
       }
       function abortStream(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortStream);
-          if (
-            "object" === typeof reason &&
-            null !== reason &&
-            reason.$$typeof === REACT_POSTPONE_TYPE
-          )
-            logPostpone$1(request, reason.message, streamTask),
-              request.type === PRERENDER
-                ? request.pendingChunks--
-                : (emitPostponeChunk(request, streamTask.id, reason),
-                  enqueueFlush(request));
-          else {
-            var digest = logRecoverableError$1(request, reason, streamTask);
-            request.type === PRERENDER
-              ? request.pendingChunks--
-              : (emitErrorChunk(request, streamTask.id, digest, reason),
-                enqueueFlush(request));
-          }
-          reader.cancel(reason).then(error, error);
-        }
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortStream),
+          request.type === PRERENDER
+            ? request.pendingChunks--
+            : (erroredTask$1(request, streamTask, reason),
+              enqueueFlush(request)),
+          reader.cancel(reason).then(error, error));
       }
       var supportsBYOB = stream.supportsBYOB;
       if (void 0 === supportsBYOB)
@@ -1030,40 +989,24 @@
             }
       }
       function error(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortIterable);
-          var digest = logRecoverableError$1(request, reason, streamTask);
-          emitErrorChunk(request, streamTask.id, digest, reason);
-          enqueueFlush(request);
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortIterable),
+          erroredTask$1(request, streamTask, reason),
+          enqueueFlush(request),
           "function" === typeof iterator.throw &&
-            iterator.throw(reason).then(error, error);
-        }
+            iterator.throw(reason).then(error, error));
       }
       function abortIterable(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortIterable);
-          if (
-            "object" === typeof reason &&
-            null !== reason &&
-            reason.$$typeof === REACT_POSTPONE_TYPE
-          )
-            logPostpone$1(request, reason.message, streamTask),
-              request.type === PRERENDER
-                ? request.pendingChunks--
-                : (emitPostponeChunk(request, streamTask.id, reason),
-                  enqueueFlush(request));
-          else {
-            var digest = logRecoverableError$1(request, reason, streamTask);
-            request.type === PRERENDER
-              ? request.pendingChunks--
-              : (emitErrorChunk(request, streamTask.id, digest, reason),
-                enqueueFlush(request));
-          }
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortIterable),
+          request.type === PRERENDER
+            ? request.pendingChunks--
+            : (erroredTask$1(request, streamTask, reason),
+              enqueueFlush(request)),
           "function" === typeof iterator.throw &&
-            iterator.throw(reason).then(error, error);
-        }
+            iterator.throw(reason).then(error, error));
       }
       var isIterator = iterable === iterator,
         streamTask = createTask(
@@ -1237,6 +1180,8 @@
         componentDebugInfo.debugStack = task.debugStack;
         componentDebugInfo.debugTask = task.debugTask;
         outlineComponentInfo(request, componentDebugInfo);
+        task.timed = !0;
+        emitTimingChunk(request, componentDebugID, performance.now());
         emitDebugChunk(request, componentDebugID, componentDebugInfo);
         task.environmentName = componentEnv;
         2 === validated &&
@@ -1480,6 +1425,7 @@
       return task;
     }
     function pingTask$1(request, task) {
+      task.timed = !0;
       var pingedTasks = request.pingedTasks;
       pingedTasks.push(task);
       1 === pingedTasks.length &&
@@ -1538,7 +1484,8 @@
             });
           return renderModel(request, task, parent, parentPropertyName, value);
         },
-        thenableState: null
+        thenableState: null,
+        timed: !1
       };
       task.environmentName = request.environmentName();
       task.debugOwner = debugOwner;
@@ -1622,38 +1569,21 @@
             );
       }
       function error(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortBlob);
-          var digest = logRecoverableError$1(request, reason, newTask);
-          emitErrorChunk(request, newTask.id, digest, reason);
-          enqueueFlush(request);
-          reader.cancel(reason).then(error, error);
-        }
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortBlob),
+          erroredTask$1(request, newTask, reason),
+          enqueueFlush(request),
+          reader.cancel(reason).then(error, error));
       }
       function abortBlob(reason) {
-        if (!aborted) {
-          aborted = !0;
-          request.abortListeners.delete(abortBlob);
-          if (
-            "object" === typeof reason &&
-            null !== reason &&
-            reason.$$typeof === REACT_POSTPONE_TYPE
-          )
-            logPostpone$1(request, reason.message, newTask),
-              request.type === PRERENDER
-                ? request.pendingChunks--
-                : (emitPostponeChunk(request, newTask.id, reason),
-                  enqueueFlush(request));
-          else {
-            var digest = logRecoverableError$1(request, reason, newTask);
-            request.type === PRERENDER
-              ? request.pendingChunks--
-              : (emitErrorChunk(request, newTask.id, digest, reason),
-                enqueueFlush(request));
-          }
-          reader.cancel(reason).then(error, error);
-        }
+        aborted ||
+          ((aborted = !0),
+          request.abortListeners.delete(abortBlob),
+          request.type === PRERENDER
+            ? request.pendingChunks--
+            : (erroredTask$1(request, newTask, reason), enqueueFlush(request)),
+          reader.cancel(reason).then(error, error));
       }
       var model = [blob.type],
         newTask = createTask(
@@ -1701,45 +1631,42 @@
           thrownValue === SuspenseException$1
             ? getSuspendedThenable$1()
             : thrownValue;
-        if ("object" === typeof key && null !== key) {
-          if ("function" === typeof key.then)
-            return (
-              (request = createTask(
-                request,
-                task.model,
-                task.keyPath,
-                task.implicitSlot,
-                request.abortableTasks,
-                task.debugOwner,
-                task.debugStack,
-                task.debugTask
-              )),
-              (value = request.ping),
-              key.then(value, value),
-              (request.thenableState = getThenableStateAfterSuspending$1()),
-              (task.keyPath = prevKeyPath),
-              (task.implicitSlot = prevImplicitSlot),
-              parent
-                ? "$L" + request.id.toString(16)
-                : serializeByValueID$1(request.id)
-            );
-          if (key.$$typeof === REACT_POSTPONE_TYPE)
-            return (
-              request.pendingChunks++,
-              (value = request.nextChunkId++),
-              logPostpone$1(request, key.message, task),
-              emitPostponeChunk(request, value, key),
-              (task.keyPath = prevKeyPath),
-              (task.implicitSlot = prevImplicitSlot),
-              parent ? "$L" + value.toString(16) : serializeByValueID$1(value)
-            );
-        }
+        if (
+          "object" === typeof key &&
+          null !== key &&
+          "function" === typeof key.then
+        )
+          return (
+            (request = createTask(
+              request,
+              task.model,
+              task.keyPath,
+              task.implicitSlot,
+              request.abortableTasks,
+              task.debugOwner,
+              task.debugStack,
+              task.debugTask
+            )),
+            (value = request.ping),
+            key.then(value, value),
+            (request.thenableState = getThenableStateAfterSuspending$1()),
+            (task.keyPath = prevKeyPath),
+            (task.implicitSlot = prevImplicitSlot),
+            parent
+              ? "$L" + request.id.toString(16)
+              : serializeByValueID$1(request.id)
+          );
         task.keyPath = prevKeyPath;
         task.implicitSlot = prevImplicitSlot;
         request.pendingChunks++;
         prevKeyPath = request.nextChunkId++;
-        task = logRecoverableError$1(request, key, task);
-        emitErrorChunk(request, prevKeyPath, task, key);
+        "object" === typeof key &&
+        null !== key &&
+        key.$$typeof === REACT_POSTPONE_TYPE
+          ? (logPostpone$1(request, key.message, task),
+            emitPostponeChunk(request, prevKeyPath, key))
+          : ((task = logRecoverableError$1(request, key, task)),
+            emitErrorChunk(request, prevKeyPath, task, key));
         return parent
           ? "$L" + prevKeyPath.toString(16)
           : serializeByValueID$1(prevKeyPath);
@@ -2486,12 +2413,24 @@
       }
       request.completedRegularChunks.push(":W" + json + "\n");
     }
+    function emitTimeOriginChunk(request, timeOrigin) {
+      request.pendingChunks++;
+      request.completedRegularChunks.push(":N" + timeOrigin + "\n");
+    }
     function forwardDebugInfo(request, id, debugInfo) {
       for (var i = 0; i < debugInfo.length; i++)
         request.pendingChunks++,
-          "string" === typeof debugInfo[i].name &&
-            outlineComponentInfo(request, debugInfo[i]),
-          emitDebugChunk(request, id, debugInfo[i]);
+          "number" === typeof debugInfo[i].time
+            ? emitTimingChunk(request, id, debugInfo[i].time)
+            : ("string" === typeof debugInfo[i].name &&
+                outlineComponentInfo(request, debugInfo[i]),
+              emitDebugChunk(request, id, debugInfo[i]));
+    }
+    function emitTimingChunk(request, id, timestamp) {
+      request.pendingChunks++;
+      timestamp -= request.timeOrigin;
+      id = id.toString(16) + ':D{"time":' + timestamp + "}\n";
+      request.completedRegularChunks.push(id);
     }
     function emitChunk(request, task, value) {
       var id = task.id;
@@ -2524,6 +2463,22 @@
                                 : ((value = stringify(value, task.toJSON)),
                                   emitModelChunk(request, task.id, value));
     }
+    function erroredTask$1(request, task, error) {
+      task.timed && emitTimingChunk(request, task.id, performance.now());
+      request.abortableTasks.delete(task);
+      task.status = ERRORED$2;
+      if (
+        "object" === typeof error &&
+        null !== error &&
+        error.$$typeof === REACT_POSTPONE_TYPE
+      )
+        logPostpone$1(request, error.message, task),
+          emitPostponeChunk(request, task.id, error);
+      else {
+        var digest = logRecoverableError$1(request, error, task);
+        emitErrorChunk(request, task.id, digest, error);
+      }
+    }
     function retryTask$1(request, task) {
       if (task.status === PENDING$3) {
         var prevDebugID = debugID;
@@ -2542,22 +2497,19 @@
           modelRoot = resolvedModel;
           task.keyPath = null;
           task.implicitSlot = !1;
-          if ("object" === typeof resolvedModel && null !== resolvedModel) {
+          var currentEnv = (0, request.environmentName)();
+          currentEnv !== task.environmentName &&
+            (request.pendingChunks++,
+            emitDebugChunk(request, task.id, { env: currentEnv }));
+          task.timed && emitTimingChunk(request, task.id, performance.now());
+          if ("object" === typeof resolvedModel && null !== resolvedModel)
             request.writtenObjects.set(
               resolvedModel,
               serializeByValueID$1(task.id)
-            );
-            var currentEnv = (0, request.environmentName)();
-            currentEnv !== task.environmentName &&
-              (request.pendingChunks++,
-              emitDebugChunk(request, task.id, { env: currentEnv }));
-            emitChunk(request, task, resolvedModel);
-          } else {
-            var json = stringify(resolvedModel),
-              _currentEnv = (0, request.environmentName)();
-            _currentEnv !== task.environmentName &&
-              (request.pendingChunks++,
-              emitDebugChunk(request, task.id, { env: _currentEnv }));
+            ),
+              emitChunk(request, task, resolvedModel);
+          else {
+            var json = stringify(resolvedModel);
             emitModelChunk(request, task.id, json);
           }
           request.abortableTasks.delete(task);
@@ -2579,26 +2531,16 @@
               thrownValue === SuspenseException$1
                 ? getSuspendedThenable$1()
                 : thrownValue;
-            if ("object" === typeof x && null !== x) {
-              if ("function" === typeof x.then) {
-                task.status = PENDING$3;
-                task.thenableState = getThenableStateAfterSuspending$1();
-                var ping = task.ping;
-                x.then(ping, ping);
-                return;
-              }
-              if (x.$$typeof === REACT_POSTPONE_TYPE) {
-                request.abortableTasks.delete(task);
-                task.status = ERRORED$2;
-                logPostpone$1(request, x.message, task);
-                emitPostponeChunk(request, task.id, x);
-                return;
-              }
-            }
-            request.abortableTasks.delete(task);
-            task.status = ERRORED$2;
-            var digest = logRecoverableError$1(request, x, task);
-            emitErrorChunk(request, task.id, digest, x);
+            if (
+              "object" === typeof x &&
+              null !== x &&
+              "function" === typeof x.then
+            ) {
+              task.status = PENDING$3;
+              task.thenableState = getThenableStateAfterSuspending$1();
+              var ping = task.ping;
+              x.then(ping, ping);
+            } else erroredTask$1(request, task, x);
           }
         } finally {
           debugID = prevDebugID;
@@ -2643,6 +2585,7 @@
     function abortTask$1(task, request, errorId) {
       task.status !== RENDERING$1 &&
         ((task.status = ABORTED$1),
+        task.timed && emitTimingChunk(request, task.id, performance.now()),
         (errorId = serializeByValueID$1(errorId)),
         (task = encodeReferenceChunk(request, task.id, errorId)),
         request.completedErrorChunks.push(task));
@@ -2727,29 +2670,25 @@
         11 >= request.status && (request.status = ABORTING$1);
         var abortableTasks = request.abortableTasks;
         if (0 < abortableTasks.size) {
-          if (
+          if (request.type === PRERENDER)
+            abortableTasks.forEach(function (task) {
+              task.status !== RENDERING$1 &&
+                ((task.status = ABORTED$1), request.pendingChunks--);
+            });
+          else if (
             "object" === typeof reason &&
             null !== reason &&
             reason.$$typeof === REACT_POSTPONE_TYPE
-          )
-            if (
-              (logPostpone$1(request, reason.message, null),
-              request.type === PRERENDER)
-            )
-              abortableTasks.forEach(function (task) {
-                task.status !== RENDERING$1 &&
-                  ((task.status = ABORTED$1), request.pendingChunks--);
-              });
-            else {
-              var errorId = request.nextChunkId++;
-              request.fatalError = errorId;
-              request.pendingChunks++;
-              emitPostponeChunk(request, errorId, reason);
-              abortableTasks.forEach(function (task) {
-                return abortTask$1(task, request, errorId);
-              });
-            }
-          else {
+          ) {
+            logPostpone$1(request, reason.message, null);
+            var errorId = request.nextChunkId++;
+            request.fatalError = errorId;
+            request.pendingChunks++;
+            emitPostponeChunk(request, errorId, reason);
+            abortableTasks.forEach(function (task) {
+              return abortTask$1(task, request, errorId);
+            });
+          } else {
             var error =
                 void 0 === reason
                   ? Error(
@@ -2762,21 +2701,14 @@
                         "The render was aborted by the server with a promise."
                       )
                     : reason,
-              digest = logRecoverableError$1(request, error, null);
-            if (request.type === PRERENDER)
-              abortableTasks.forEach(function (task) {
-                task.status !== RENDERING$1 &&
-                  ((task.status = ABORTED$1), request.pendingChunks--);
-              });
-            else {
-              var _errorId2 = request.nextChunkId++;
-              request.fatalError = _errorId2;
-              request.pendingChunks++;
-              emitErrorChunk(request, _errorId2, digest, error);
-              abortableTasks.forEach(function (task) {
-                return abortTask$1(task, request, _errorId2);
-              });
-            }
+              digest = logRecoverableError$1(request, error, null),
+              _errorId2 = request.nextChunkId++;
+            request.fatalError = _errorId2;
+            request.pendingChunks++;
+            emitErrorChunk(request, _errorId2, digest, error);
+            abortableTasks.forEach(function (task) {
+              return abortTask$1(task, request, _errorId2);
+            });
           }
           abortableTasks.clear();
           var onAllReady = request.onAllReady;
@@ -3545,6 +3477,7 @@
       this.value = value;
       this.reason = reason;
       this._response = response;
+      this._children = [];
       this._debugInfo = null;
     }
     function readChunk(chunk) {
@@ -3637,12 +3570,14 @@
       }
     }
     function initializeModelChunk(chunk) {
-      var prevHandler = initializingHandler;
+      var prevHandler = initializingHandler,
+        prevChunk = initializingChunk;
       initializingHandler = null;
       var resolvedModel = chunk.value;
       chunk.status = "blocked";
       chunk.value = null;
       chunk.reason = null;
+      initializingChunk = chunk;
       try {
         var value = JSON.parse(resolvedModel, chunk._response._fromJSON),
           resolveListeners = chunk.value;
@@ -3663,7 +3598,7 @@
       } catch (error) {
         (chunk.status = "rejected"), (chunk.reason = error);
       } finally {
-        initializingHandler = prevHandler;
+        (initializingHandler = prevHandler), (initializingChunk = prevChunk);
       }
     }
     function initializeModuleChunk(chunk) {
@@ -3679,6 +3614,7 @@
       response._chunks.forEach(function (chunk) {
         "pending" === chunk.status && triggerErrorOnChunk(chunk, error);
       });
+      flushComponentPerformance(getChunk(response, 0));
     }
     function nullRefGetter() {
       return null;
@@ -3819,6 +3755,9 @@
       reference = reference.split(":");
       var id = parseInt(reference[0], 16);
       id = getChunk(response, id);
+      null !== initializingChunk &&
+        isArrayImpl(initializingChunk._children) &&
+        initializingChunk._children.push(id);
       switch (id.status) {
         case "resolved_model":
           initializeModelChunk(id);
@@ -3927,12 +3866,19 @@
             return (
               (parentObject = parseInt(value.slice(2), 16)),
               (response = getChunk(response, parentObject)),
+              null !== initializingChunk &&
+                isArrayImpl(initializingChunk._children) &&
+                initializingChunk._children.push(response),
               createLazyChunkWrapper(response)
             );
           case "@":
             if (2 === value.length) return new Promise(function () {});
             parentObject = parseInt(value.slice(2), 16);
-            return getChunk(response, parentObject);
+            response = getChunk(response, parentObject);
+            null !== initializingChunk &&
+              isArrayImpl(initializingChunk._children) &&
+              initializingChunk._children.push(response);
+            return response;
           case "S":
             return Symbol.for(value.slice(2));
           case "F":
@@ -4069,6 +4015,7 @@
       this._rowLength = this._rowTag = this._rowID = this._rowState = 0;
       this._buffer = [];
       this._tempRefs = temporaryReferences;
+      this._timeOrigin = 0;
       this._debugRootOwner = bundlerConfig =
         void 0 === ReactSharedInteralsServer ||
         null === ReactSharedInteralsServer.A
@@ -4492,10 +4439,13 @@
       void 0 !== debugInfo.stack &&
         initializeFakeTask(response, debugInfo, env);
       null === debugInfo.owner && null != response._debugRootOwner
-        ? ((debugInfo.owner = response._debugRootOwner),
-          (debugInfo.debugStack = response._debugRootStack))
+        ? ((env = debugInfo),
+          (env.owner = response._debugRootOwner),
+          (env.debugStack = response._debugRootStack))
         : void 0 !== debugInfo.stack &&
           initializeFakeStack(response, debugInfo);
+      "number" === typeof debugInfo.time &&
+        (debugInfo = { time: debugInfo.time + response._timeOrigin });
       response = getChunk(response, id);
       (response._debugInfo || (response._debugInfo = [])).push(debugInfo);
     }
@@ -4521,6 +4471,50 @@
         );
       }
     }
+    function flushComponentPerformance(root) {
+      if (!isArrayImpl(root._children)) return root._children.endTime;
+      var children = root._children;
+      "resolved_model" === root.status && initializeModelChunk(root);
+      var result = { endTime: -Infinity };
+      root._children = result;
+      for (var childrenEndTime = -Infinity, i = 0; i < children.length; i++) {
+        var childEndTime = flushComponentPerformance(children[i]);
+        childEndTime > childrenEndTime && (childrenEndTime = childEndTime);
+      }
+      if ((root = root._debugInfo))
+        for (children = 0, i = root.length - 1; 0 <= i; i--)
+          if (
+            ((childEndTime = root[i]),
+            "number" === typeof childEndTime.time &&
+              ((children = childEndTime.time),
+              children > childrenEndTime && (childrenEndTime = children)),
+            "string" === typeof childEndTime.name && 0 < i)
+          ) {
+            var componentInfo = childEndTime;
+            childEndTime = root[i - 1];
+            if ("number" === typeof childEndTime.time) {
+              childEndTime = childEndTime.time;
+              var childrenEndTime$jscomp$0 = childrenEndTime;
+              if (supportsUserTiming && 0 <= childrenEndTime$jscomp$0) {
+                componentInfo = componentInfo.name;
+                var selfTime = children - childEndTime;
+                reusableComponentDevToolDetails.color =
+                  0.5 > selfTime
+                    ? "primary-light"
+                    : 50 > selfTime
+                      ? "primary"
+                      : 500 > selfTime
+                        ? "primary-dark"
+                        : "error";
+                reusableComponentOptions.start =
+                  0 > childEndTime ? 0 : childEndTime;
+                reusableComponentOptions.end = childrenEndTime$jscomp$0;
+                performance.measure(componentInfo, reusableComponentOptions);
+              }
+            }
+          }
+      return (result.endTime = childrenEndTime);
+    }
     function processFullStringRow(response, id, tag, row) {
       switch (tag) {
         case 73:
@@ -4542,6 +4536,9 @@
         case 84:
           resolveText(response, id, row);
           break;
+        case 78:
+          response._timeOrigin = +row - performance.timeOrigin;
+          break;
         case 68:
           tag = new ReactPromise("resolved_model", row, null, response);
           initializeModelChunk(tag);
@@ -11960,6 +11957,18 @@
       fakeServerFunctionIdx = 0,
       FunctionBind = Function.prototype.bind,
       ArraySlice = Array.prototype.slice,
+      supportsUserTiming =
+        "undefined" !== typeof performance &&
+        "function" === typeof performance.measure,
+      reusableComponentDevToolDetails = {
+        color: "primary",
+        track: "Server Components \u269b"
+      },
+      reusableComponentOptions = {
+        start: -0,
+        end: -0,
+        detail: { devtools: reusableComponentDevToolDetails }
+      },
       REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
       ReactSharedInteralsServer =
         React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
@@ -11993,6 +12002,7 @@
       }
     };
     var initializingHandler = null,
+      initializingChunk = null,
       supportsCreateTask = !!console.createTask,
       fakeFunctionCache = new Map(),
       fakeFunctionIdx = 0,
@@ -13177,5 +13187,5 @@
         });
       });
     };
-    exports.version = "19.0.0-experimental-372ec00c-20241209";
+    exports.version = "19.1.0-experimental-7130d0c6-20241212";
   })();