test-renderer 0.14.0 → 0.15.0

package/dist/index.cjs

@@ -74,64 +74,95 @@ var Tag = {
 };
 var CONTAINER_TYPE = "";
 
+// src/performance.ts
+function mark(name, details) {
+  if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+    return;
+  }
+  performance.mark(`test-renderer/${name}`, { detail: details });
+}
+function measureStart(name) {
+  if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+    return;
+  }
+  performance.mark(`test-renderer/${name}:start`);
+}
+function measureEnd(name, details) {
+  if (!globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+    return;
+  }
+  performance.mark(`test-renderer/${name}:end`);
+  performance.measure(`test-renderer/${name}`, {
+    start: `test-renderer/${name}:start`,
+    end: `test-renderer/${name}:end`,
+    detail: details
+  });
+}
+
+// src/reconciler.ts
+var import_react_reconciler = __toESM(require("react-reconciler"), 1);
+var import_constants3 = require("react-reconciler/constants");
+
 // src/query-all.ts
-function queryAll(element, predicate, options) {
+function queryAll(instance, predicate, options) {
   var _a, _b;
   const includeSelf = (_a = options == null ? void 0 : options.includeSelf) != null ? _a : false;
   const matchDeepestOnly = (_b = options == null ? void 0 : options.matchDeepestOnly) != null ? _b : false;
   const results = [];
   const matchingDescendants = [];
-  element.children.forEach((child) => {
+  instance.children.forEach((child) => {
     if (typeof child === "string") {
       return;
     }
     matchingDescendants.push(...queryAll(child, predicate, __spreadProps(__spreadValues({}, options), { includeSelf: true })));
   });
   if (includeSelf && // When matchDeepestOnly = true: add current element only if no descendants match
-  (matchingDescendants.length === 0 || !matchDeepestOnly) && predicate(element)) {
-    results.push(element);
+  (matchingDescendants.length === 0 || !matchDeepestOnly) && predicate(instance)) {
+    results.push(instance);
   }
   results.push(...matchingDescendants);
   return results;
 }
 
-// src/render-to-json.ts
-function renderContainerToJson(instance) {
+// src/to-json.ts
+function containerToJson(container) {
   return {
     type: CONTAINER_TYPE,
     props: {},
-    children: renderChildrenToJson(instance.children),
+    children: childrenToJson(container.children),
     $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
   };
 }
-function renderInstanceToJson(instance) {
-  if (instance.isHidden) {
+function instanceToJson(instance) {
+  const shouldExcludeHidden = instance.rootContainer.config.transformHiddenInstanceProps == null;
+  if (instance.isHidden && shouldExcludeHidden) {
     return null;
   }
   const _a = instance.props, { children: _children } = _a, restProps = __objRest(_a, ["children"]);
   return {
     type: instance.type,
     props: restProps,
-    children: renderChildrenToJson(instance.children),
+    children: childrenToJson(instance.children),
     $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
   };
 }
-function renderTextInstanceToJson(instance) {
-  if (instance.isHidden) {
+function textInstanceToJson(instance) {
+  const shouldExcludeHidden = instance.rootContainer.config.transformHiddenInstanceProps == null;
+  if (instance.isHidden && shouldExcludeHidden) {
     return null;
   }
   return instance.text;
 }
-function renderChildrenToJson(children) {
+function childrenToJson(children) {
   const result = [];
   for (const child of children) {
     if (child.tag === Tag.Instance) {
-      const renderedChild = renderInstanceToJson(child);
+      const renderedChild = instanceToJson(child);
       if (renderedChild != null) {
         result.push(renderedChild);
       }
     } else {
-      const renderedChild = renderTextInstanceToJson(child);
+      const renderedChild = textInstanceToJson(child);
       if (renderedChild != null) {
         result.push(renderedChild);
       }
@@ -140,9 +171,9 @@ function renderChildrenToJson(children) {
   return result;
 }
 
-// src/host-element.ts
+// src/test-instance.ts
 var instanceMap = /* @__PURE__ */ new WeakMap();
-var HostElement = class _HostElement {
+var TestInstance = class _TestInstance {
   constructor(instance) {
     this.instance = instance;
   }
@@ -151,6 +182,7 @@ var HostElement = class _HostElement {
     return this.instance.tag === Tag.Instance ? this.instance.type : CONTAINER_TYPE;
   }
   /** The element's props object. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   get props() {
     return this.instance.tag === Tag.Instance ? this.instance.props : {};
   }
@@ -160,11 +192,13 @@ var HostElement = class _HostElement {
     if (parentInstance == null) {
       return null;
     }
-    return _HostElement.fromInstance(parentInstance);
+    return _TestInstance.fromInstance(parentInstance);
   }
-  /** Array of child nodes (elements and text strings). Hidden children are excluded. */
+  /** Array of child nodes (elements and text strings). Hidden children are excluded by default. */
   get children() {
-    const result = this.instance.children.filter((child) => !child.isHidden).map((child) => getHostNodeForInstance(child));
+    const container = this.instance.tag === Tag.Container ? this.instance : this.instance.rootContainer;
+    const shouldExcludeHiddenChildren = container.config.transformHiddenInstanceProps == null;
+    const result = this.instance.children.filter((child) => !child.isHidden || !shouldExcludeHiddenChildren).map((child) => getTestNodeForInstance(child));
     return result;
   }
   /**
@@ -180,10 +214,10 @@ var HostElement = class _HostElement {
   /**
    * Convert this element to a JSON representation suitable for snapshots.
    *
-   * @returns JSON element or null if the element is hidden.
+   * @returns JSON element or null if the element is hidden and hidden nodes are excluded.
    */
   toJSON() {
-    return this.instance.tag === Tag.Container ? renderContainerToJson(this.instance) : renderInstanceToJson(this.instance);
+    return this.instance.tag === Tag.Container ? containerToJson(this.instance) : instanceToJson(this.instance);
   }
   /**
    * Find all descendant elements matching the predicate.
@@ -197,28 +231,24 @@ var HostElement = class _HostElement {
   }
   /** @internal */
   static fromInstance(instance) {
-    const hostElement = instanceMap.get(instance);
-    if (hostElement) {
-      return hostElement;
+    const testInstance = instanceMap.get(instance);
+    if (testInstance) {
+      return testInstance;
     }
-    const result = new _HostElement(instance);
+    const result = new _TestInstance(instance);
     instanceMap.set(instance, result);
     return result;
   }
 };
-function getHostNodeForInstance(instance) {
+function getTestNodeForInstance(instance) {
   switch (instance.tag) {
     case Tag.Text:
       return instance.text;
     case Tag.Instance:
-      return HostElement.fromInstance(instance);
+      return TestInstance.fromInstance(instance);
   }
 }
 
-// src/reconciler.ts
-var import_react_reconciler = __toESM(require("react-reconciler"), 1);
-var import_constants3 = require("react-reconciler/constants");
-
 // src/utils.ts
 function formatComponentList(names) {
   if (names.length === 0) {
@@ -300,10 +330,12 @@ var hostConfig = {
    * something when an instance is definitely in the tree, look at `commitMount` instead.
    */
   createInstance(type, props, rootContainer, _hostContext, internalHandle) {
+    mark("reconciler/createInstance", { type });
     return {
       tag: Tag.Instance,
       type,
       props,
+      propsBeforeHiding: null,
       isHidden: false,
       children: [],
       parent: null,
@@ -319,6 +351,7 @@ var hostConfig = {
    */
   createTextInstance(text, rootContainer, hostContext, _internalHandle) {
     var _a;
+    mark("reconciler/createTextInstance", { text });
     if (rootContainer.config.textComponentTypes && !hostContext.isInsideText) {
       const componentTypes = (_a = rootContainer.config.publicTextComponentTypes) != null ? _a : rootContainer.config.textComponentTypes;
       throw new Error(
@@ -331,6 +364,7 @@ var hostConfig = {
       tag: Tag.Text,
       text,
       parent: null,
+      rootContainer,
       isHidden: false
     };
   },
@@ -344,7 +378,15 @@ var hostConfig = {
    * must not modify any other nodes. It's called while the tree is still being built up and not connected
    * to the actual tree on the screen.
    */
-  appendInitialChild: appendChild,
+  appendInitialChild(parentInstance, child) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/appendInitialChild", {
+        parentType: parentInstance.type,
+        childType: formatInstanceType(child)
+      });
+    }
+    appendChild(parentInstance, child);
+  },
   /**
    * #### `finalizeInitialChildren(instance, type, props, rootContainer, hostContext)`
    *
@@ -361,7 +403,8 @@ var hostConfig = {
    *
    * If you don't want to do anything here, you should return `false`.
    */
-  finalizeInitialChildren(_instance, _type, _props, _rootContainer, _hostContext) {
+  finalizeInitialChildren(instance, _type, _props, _rootContainer, _hostContext) {
+    mark("reconciler/finalizeInitialChildren", { type: instance.type });
     return false;
   },
   /**
@@ -379,19 +422,24 @@ var hostConfig = {
    * If you don't want to do anything here, you should return `false`.
    * This method happens **in the render phase**. Do not mutate the tree from it.
    */
-  shouldSetTextContent(_type, _props) {
+  shouldSetTextContent(type, _props) {
+    mark("reconciler/shouldSetTextContent", { type, result: false });
     return false;
   },
-  setCurrentUpdatePriority(newPriority) {
-    currentUpdatePriority = newPriority;
+  setCurrentUpdatePriority(priority) {
+    mark("reconciler/setCurrentUpdatePriority", { priority });
+    currentUpdatePriority = priority;
   },
   getCurrentUpdatePriority() {
     return currentUpdatePriority;
   },
   resolveUpdatePriority() {
-    return currentUpdatePriority || import_constants3.DefaultEventPriority;
+    const priority = currentUpdatePriority || import_constants3.DefaultEventPriority;
+    mark("reconciler/resolveUpdatePriority", { priority });
+    return priority;
   },
   shouldAttemptEagerTransition() {
+    mark("reconciler/shouldAttemptEagerTransition", { result: false });
     return false;
   },
   /**
@@ -404,6 +452,7 @@ var hostConfig = {
    * This method happens **in the render phase**. Do not mutate the tree from it.
    */
   getRootHostContext(rootContainer) {
+    mark("reconciler/getRootHostContext");
     return {
       type: "ROOT",
       config: rootContainer.config,
@@ -428,6 +477,7 @@ var hostConfig = {
    */
   getChildHostContext(parentHostContext, type) {
     var _a;
+    mark("reconciler/getChildHostContext", { type });
     const isInsideText = Boolean((_a = parentHostContext.config.textComponentTypes) == null ? void 0 : _a.includes(type));
     return __spreadProps(__spreadValues({}, parentHostContext), { type, isInsideText });
   },
@@ -440,19 +490,19 @@ var hostConfig = {
    * If you don't want to do anything here, return `instance`.
    */
   getPublicInstance(instance) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/getPublicInstance", {
+        type: formatInstanceType(instance)
+      });
+    }
     switch (instance.tag) {
       case Tag.Instance: {
-        const createNodeMock = instance.rootContainer.config.createNodeMock;
-        const mockNode = createNodeMock({
-          type: instance.type,
-          props: instance.props,
-          key: null
-        });
-        nodeToInstanceMap.set(mockNode, instance);
-        return mockNode;
+        const testInstance = TestInstance.fromInstance(instance);
+        nodeToInstanceMap.set(testInstance, instance);
+        return testInstance;
       }
       default:
-        return instance;
+        return null;
     }
   },
   /**
@@ -465,6 +515,8 @@ var hostConfig = {
    * Even if you don't want to do anything here, you need to return `null` from it.
    */
   prepareForCommit(_containerInfo) {
+    mark("reconciler/prepareForCommit");
+    measureStart("react/commit");
     return null;
   },
   /**
@@ -476,6 +528,8 @@ var hostConfig = {
    * You can leave it empty.
    */
   resetAfterCommit(_containerInfo) {
+    measureEnd("react/commit");
+    mark("reconciler/resetAfterCommit");
   },
   /**
    * #### `preparePortalMount(containerInfo)`
@@ -483,19 +537,31 @@ var hostConfig = {
    * This method is called for a container that's used as a portal target. Usually you can leave it empty.
    */
   preparePortalMount(_containerInfo) {
+    mark("reconciler/preparePortalMount");
   },
   /**
    * #### `scheduleTimeout(fn, delay)`
    *
    * You can proxy this to `setTimeout` or its equivalent in your environment.
    */
-  scheduleTimeout: setTimeout,
+  scheduleTimeout(fn, delay) {
+    const id = setTimeout(() => {
+      mark("reconciler/scheduled timeout:start");
+      fn();
+      mark("reconciler/scheduled timeout:end");
+    }, delay);
+    mark("reconciler/scheduleTimeout", { id });
+    return id;
+  },
   /**
    * #### `cancelTimeout(id)`
    *
    * You can proxy this to `clearTimeout` or its equivalent in your environment.
    */
-  cancelTimeout: clearTimeout,
+  cancelTimeout(id) {
+    mark("reconciler/cancelTimeout", { id });
+    clearTimeout(id);
+  },
   /**
    * #### `noTimeout`
    *
@@ -517,7 +583,14 @@ var hostConfig = {
    *
    * Optional. You can proxy this to `queueMicrotask` or its equivalent in your environment.
    */
-  scheduleMicrotask: queueMicrotask,
+  scheduleMicrotask(fn) {
+    mark("reconciler/scheduleMicrotask");
+    queueMicrotask(() => {
+      mark("reconciler/scheduled microtask:start");
+      fn();
+      mark("reconciler/scheduled microtask:end");
+    });
+  },
   /**
    * #### `isPrimaryRenderer`
    *
@@ -531,6 +604,7 @@ var hostConfig = {
    */
   warnsIfNotActing: true,
   getInstanceFromNode(node) {
+    mark("reconciler/getInstanceFromNode");
     const instance = nodeToInstanceMap.get(node);
     if (instance !== void 0) {
       return instance.unstable_fiber;
@@ -538,17 +612,22 @@ var hostConfig = {
     return null;
   },
   beforeActiveInstanceBlur() {
+    mark("reconciler/beforeActiveInstanceBlur");
   },
   afterActiveInstanceBlur() {
+    mark("reconciler/afterActiveInstanceBlur");
   },
   prepareScopeUpdate(scopeInstance, instance) {
+    mark("reconciler/prepareScopeUpdate");
     nodeToInstanceMap.set(scopeInstance, instance);
   },
   getInstanceFromScope(scopeInstance) {
     var _a;
+    mark("reconciler/getInstanceFromScope");
     return (_a = nodeToInstanceMap.get(scopeInstance)) != null ? _a : null;
   },
   detachDeletedInstance(_node) {
+    mark("reconciler/detachDeletedInstance");
   },
   /**
    * #### `appendChild(parentInstance, child)`
@@ -559,7 +638,15 @@ var hostConfig = {
    * Although this method currently runs in the commit phase, you still should not mutate any other nodes
    * in it. If you need to do some additional work when a node is definitely connected to the visible tree, look at `commitMount`.
    */
-  appendChild,
+  appendChild(parentInstance, child) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/appendChild", {
+        parentType: parentInstance.type,
+        childType: formatInstanceType(child)
+      });
+    }
+    appendChild(parentInstance, child);
+  },
   /**
    * #### `appendChildToContainer(container, child)`
    *
@@ -567,7 +654,14 @@ var hostConfig = {
    * to the root has a slightly different implementation, or if the root container nodes are of a different
    * type than the rest of the tree.
    */
-  appendChildToContainer: appendChild,
+  appendChildToContainer(container, child) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/appendChildToContainer", {
+        childType: formatInstanceType(child)
+      });
+    }
+    appendChild(container, child);
+  },
   /**
    * #### `insertBefore(parentInstance, child, beforeChild)`
    *
@@ -577,7 +671,16 @@ var hostConfig = {
    * Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is expected
    * that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts of the tree from it.
    */
-  insertBefore,
+  insertBefore(parentInstance, child, beforeChild) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/insertBefore", {
+        parentType: parentInstance.type,
+        childType: formatInstanceType(child),
+        beforeChildType: formatInstanceType(beforeChild)
+      });
+    }
+    insertBefore(parentInstance, child, beforeChild);
+  },
   /**
    * #### `insertInContainerBefore(container, child, beforeChild)
    *
@@ -585,7 +688,15 @@ var hostConfig = {
    * to the root has a slightly different implementation, or if the root container nodes are of a different type
    * than the rest of the tree.
    */
-  insertInContainerBefore: insertBefore,
+  insertInContainerBefore(container, child, beforeChild) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/insertInContainerBefore", {
+        childType: formatInstanceType(child),
+        beforeChildType: formatInstanceType(beforeChild)
+      });
+    }
+    insertBefore(container, child, beforeChild);
+  },
   /**
    * #### `removeChild(parentInstance, child)`
    *
@@ -594,7 +705,15 @@ var hostConfig = {
    * React will only call it for the top-level node that is being removed. It is expected that garbage collection
    * would take care of the whole subtree. You are not expected to traverse the child tree in it.
    */
-  removeChild,
+  removeChild(parentInstance, child) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/removeChild", {
+        parentType: parentInstance.type,
+        childType: formatInstanceType(child)
+      });
+    }
+    removeChild(parentInstance, child);
+  },
   /**
    * #### `removeChildFromContainer(container, child)`
    *
@@ -602,7 +721,14 @@ var hostConfig = {
    * to the root has a slightly different implementation, or if the root container nodes are of a different type
    * than the rest of the tree.
    */
-  removeChildFromContainer: removeChild,
+  removeChildFromContainer(container, child) {
+    if (globalThis.TEST_RENDERER_ENABLE_PROFILING) {
+      mark("reconciler/removeChildFromContainer", {
+        childType: formatInstanceType(child)
+      });
+    }
+    removeChild(container, child);
+  },
   /**
    * #### `resetTextContent(instance)`
    *
@@ -612,7 +738,8 @@ var hostConfig = {
    *
    * If you never return `true` from `shouldSetTextContent`, you can leave it empty.
    */
-  resetTextContent(_instance) {
+  resetTextContent(instance) {
+    mark("reconciler/resetTextContent", { type: instance.type });
   },
   /**
    * #### `commitTextUpdate(textInstance, prevText, nextText)`
@@ -621,7 +748,8 @@ var hostConfig = {
    *
    * Here, `textInstance` is a node created by `createTextInstance`.
    */
-  commitTextUpdate(textInstance, _oldText, newText) {
+  commitTextUpdate(textInstance, oldText, newText) {
+    mark("reconciler/commitTextUpdate", { oldText, newText });
     textInstance.text = newText;
   },
   /**
@@ -643,7 +771,8 @@ var hostConfig = {
    *
    * If you never return `true` from `finalizeInitialChildren`, you can leave it empty.
    */
-  commitMount(_instance, _type, _props, _internalHandle) {
+  commitMount(_instance, type, _props, _internalHandle) {
+    mark("reconciler/commitMount", { type });
   },
   /**
    * #### `commitUpdate(instance, type, prevProps, nextProps, internalHandle)`
@@ -661,8 +790,18 @@ var hostConfig = {
   // @ts-expect-error @types/react-reconciler types don't fully match react-reconciler's actual Flow types.
   // Correctness is verified through tests.
   commitUpdate(instance, type, _prevProps, nextProps, internalHandle) {
+    mark("reconciler/commitUpdate", { type });
     instance.type = type;
-    instance.props = nextProps;
+    if (instance.isHidden && instance.rootContainer.config.transformHiddenInstanceProps != null) {
+      instance.propsBeforeHiding = nextProps;
+      instance.props = instance.rootContainer.config.transformHiddenInstanceProps({
+        props: nextProps,
+        type: instance.type
+      });
+    } else {
+      instance.props = nextProps;
+      instance.propsBeforeHiding = null;
+    }
     instance.unstable_fiber = internalHandle;
   },
   /**
@@ -672,7 +811,17 @@ var hostConfig = {
    * visual styling to hide it. It is used by Suspense to hide the tree while the fallback is visible.
    */
   hideInstance(instance) {
+    mark("reconciler/hideInstance", { type: instance.type });
+    if (instance.isHidden) {
+      return;
+    }
     instance.isHidden = true;
+    instance.propsBeforeHiding = instance.props;
+    const transformHiddenInstanceProps = instance.rootContainer.config.transformHiddenInstanceProps;
+    if (transformHiddenInstanceProps) {
+      const { props, type } = instance;
+      instance.props = transformHiddenInstanceProps({ props, type });
+    }
   },
   /**
    * #### `hideTextInstance(textInstance)`
@@ -680,6 +829,7 @@ var hostConfig = {
    * Same as `hideInstance`, but for nodes created by `createTextInstance`.
    */
   hideTextInstance(textInstance) {
+    mark("reconciler/hideTextInstance", { text: textInstance.text });
     textInstance.isHidden = true;
   },
   /**
@@ -688,7 +838,13 @@ var hostConfig = {
    * This method should make the `instance` visible, undoing what `hideInstance` did.
    */
   unhideInstance(instance, _props) {
+    mark("reconciler/unhideInstance", { type: instance.type });
     instance.isHidden = false;
+    const transformHiddenInstanceProps = instance.rootContainer.config.transformHiddenInstanceProps;
+    if (transformHiddenInstanceProps && instance.propsBeforeHiding) {
+      instance.props = instance.propsBeforeHiding;
+      instance.propsBeforeHiding = null;
+    }
   },
   /**
    * #### `unhideTextInstance(textInstance, text)`
@@ -696,6 +852,7 @@ var hostConfig = {
    * Same as `unhideInstance`, but for nodes created by `createTextInstance`.
    */
   unhideTextInstance(textInstance, _text) {
+    mark("reconciler/unhideTextInstance", { text: textInstance.text });
     textInstance.isHidden = false;
   },
   /**
@@ -704,6 +861,7 @@ var hostConfig = {
    * This method should mutate the `container` root node and remove all children from it.
    */
   clearContainer(container) {
+    mark("reconciler/clearContainer");
     container.children.forEach((child) => {
       child.parent = null;
     });
@@ -715,7 +873,8 @@ var hostConfig = {
    * This method is called during render to determine if the Host Component type and props require
    * some kind of loading process to complete before committing an update.
    */
-  maySuspendCommit(_type, _props) {
+  maySuspendCommit(type, _props) {
+    mark("reconciler/maySuspendCommit", { type });
     return false;
   },
   /**
@@ -724,7 +883,8 @@ var hostConfig = {
    * This method may be called during render if the Host Component type and props might suspend a commit.
    * It can be used to initiate any work that might shorten the duration of a suspended commit.
    */
-  preloadInstance(_type, _props) {
+  preloadInstance(type, _props) {
+    mark("reconciler/preloadInstance", { type });
     return true;
   },
   /**
@@ -734,6 +894,7 @@ var hostConfig = {
    * Components that might suspend this commit are evaluated to determine if the commit must be suspended.
    */
   startSuspendingCommit() {
+    mark("reconciler/startSuspendingCommit");
   },
   /**
    * #### `suspendInstance(type, props)`
@@ -741,7 +902,8 @@ var hostConfig = {
    * This method is called after `startSuspendingCommit` for each Host Component that indicated it might
    * suspend a commit.
    */
-  suspendInstance() {
+  suspendInstance(type, _props) {
+    mark("reconciler/suspendInstance", { type });
   },
   /**
    * #### `waitForCommitToBeReady()`
@@ -753,7 +915,8 @@ var hostConfig = {
    * callback will initiate the commit when called. The return value is a cancellation function that the
    * Reconciler can use to abort the commit.
    */
-  waitForCommitToBeReady() {
+  waitForCommitToBeReady(type, _props) {
+    mark("reconciler/waitForCommitToBeReady", { type });
     return null;
   },
   // -------------------
@@ -769,8 +932,10 @@ var hostConfig = {
   supportsHydration: false,
   NotPendingTransition: null,
   resetFormInstance(_form) {
+    mark("reconciler/resetFormInstance");
   },
   requestPostPaintCallback(_callback) {
+    mark("reconciler/requestPostPaintCallback");
   }
 };
 var TestReconciler = (0, import_react_reconciler.default)(hostConfig);
@@ -796,9 +961,11 @@ function removeChild(parentInstance, child) {
   parentInstance.children.splice(index, 1);
   child.parent = null;
 }
+function formatInstanceType(instance) {
+  return instance.tag === Tag.Text ? `text: "${instance.text}"` : instance.type;
+}
 
 // src/renderer.ts
-var defaultCreateMockNode = () => ({});
 var defaultOnUncaughtError = (error, errorInfo) => {
   console.error("Uncaught error:", error, errorInfo);
 };
@@ -809,7 +976,8 @@ var defaultOnRecoverableError = (error, errorInfo) => {
   console.error("Recoverable error:", error, errorInfo);
 };
 function createRoot(options) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e;
+  measureStart("createRoot");
   let container = {
     tag: Tag.Container,
     parent: null,
@@ -818,7 +986,7 @@ function createRoot(options) {
     config: {
       textComponentTypes: options == null ? void 0 : options.textComponentTypes,
       publicTextComponentTypes: options == null ? void 0 : options.publicTextComponentTypes,
-      createNodeMock: (_a = options == null ? void 0 : options.createNodeMock) != null ? _a : defaultCreateMockNode
+      transformHiddenInstanceProps: options == null ? void 0 : options.transformHiddenInstanceProps
     }
   };
   let containerFiber = TestReconciler.createContainer(
@@ -826,30 +994,41 @@ function createRoot(options) {
     import_constants5.ConcurrentRoot,
     null,
     // hydrationCallbacks
-    (_b = options == null ? void 0 : options.isStrictMode) != null ? _b : false,
+    (_a = options == null ? void 0 : options.isStrictMode) != null ? _a : false,
     false,
     // concurrentUpdatesByDefaultOverride
-    (_c = options == null ? void 0 : options.identifierPrefix) != null ? _c : "",
-    (_d = options == null ? void 0 : options.onUncaughtError) != null ? _d : defaultOnUncaughtError,
-    (_e = options == null ? void 0 : options.onCaughtError) != null ? _e : defaultOnCaughtError,
+    (_b = options == null ? void 0 : options.identifierPrefix) != null ? _b : "",
+    (_c = options == null ? void 0 : options.onUncaughtError) != null ? _c : defaultOnUncaughtError,
+    (_d = options == null ? void 0 : options.onCaughtError) != null ? _d : defaultOnCaughtError,
     // @ts-expect-error @types/react-reconciler types don't include onRecoverableError parameter
     // in the createContainer signature, but react-reconciler's actual Flow types do.
     // Correctness is verified through tests.
-    (_f = options == null ? void 0 : options.onRecoverableError) != null ? _f : defaultOnRecoverableError,
+    (_e = options == null ? void 0 : options.onRecoverableError) != null ? _e : defaultOnRecoverableError,
     null
     // transitionCallbacks
   );
+  measureEnd("createRoot");
   const render = (element) => {
     if (containerFiber == null) {
       throw new Error("Cannot render after unmount");
     }
-    TestReconciler.updateContainer(element, containerFiber, null, null);
+    measureStart("render");
+    try {
+      TestReconciler.updateContainer(element, containerFiber, null, null);
+    } finally {
+      measureEnd("render", { elementType: String(element.type) });
+    }
   };
   const unmount = () => {
     if (container == null) {
       return;
     }
-    TestReconciler.updateContainer(null, containerFiber, null, null);
+    measureStart("unmount");
+    try {
+      TestReconciler.updateContainer(null, containerFiber, null, null);
+    } finally {
+      measureEnd("unmount");
+    }
     containerFiber = null;
     container = null;
   };
@@ -860,7 +1039,7 @@ function createRoot(options) {
       if (container == null) {
         throw new Error("Cannot access .container on unmounted test renderer");
       }
-      return HostElement.fromInstance(container);
+      return TestInstance.fromInstance(container);
     }
   };
 }