bippy 0.7.3-dev.ebf9a42 → 0.7.3-dev.fbafc40

package/src/core.ts

@@ -1,6 +1,6 @@
 // React must remain a type-only import because this module loads immediately after the DevTools hook.
 import type * as React from "react";
-import { callListener } from "./call-listener.js";
+import { callListener } from "./call-listener";
 
 import type {
   Fiber,
@@ -8,7 +8,7 @@ import type {
   HostFiber,
   ReactDevToolsGlobalHook,
   ReactRenderer,
-} from "./react-internals/index.js";
+} from "./react-internals/index";
 
 import {
   BIPPY_INSTRUMENTATION_STRING,
@@ -20,16 +20,16 @@ import {
   isRealReactDevtools,
   onRDTHookReplace,
   removeActiveListener,
-} from "./rdt-hook.js";
-import type { ReactDevToolsTarget, Unsubscribe } from "./rdt-hook.js";
-import { getCurrentFiberFromRoot } from "./react-internals/current-fiber.js";
+} from "./rdt-hook";
+import type { ReactDevToolsTarget, Unsubscribe } from "./rdt-hook";
+import { getCurrentFiberFromRoot } from "./react-internals/current-fiber";
 import {
   getReactWorkTagsForFiber,
   ReactBuildType,
   ReactFiberFlags,
   ReactSymbols,
   setReactWorkTagsForFiber,
-} from "./react-internals/index.js";
+} from "./react-internals/index";
 
 export {
   BippyError,
@@ -37,7 +37,7 @@ export {
   BippyHookRenderError,
   BippySourceMapError,
   BippyUnsupportedHookError,
-} from "./errors.js";
+} from "./errors";
 
 const isComponentType = (value: unknown): value is React.ComponentType<unknown> =>
   typeof value === "function";
@@ -248,8 +248,15 @@ export const traverseFiber = ((
     while (currentFiber) {
       const selectedFiber = currentFiber;
       const selection = selector(selectedFiber);
-      if (isPromiseLike<boolean | void>(selection)) {
-        return Promise.resolve(selection).then((didSelectFiber) =>
+      const then =
+        selection !== null && (typeof selection === "object" || typeof selection === "function")
+          ? selection.then
+          : null;
+      if (typeof then === "function") {
+        return Promise.resolve<boolean | void>({
+          // oxlint-disable-next-line unicorn/no-thenable -- Assimilate the captured method without reading the accessor twice.
+          then: (resolve, reject) => Reflect.apply(then, selection, [resolve, reject]),
+        }).then((didSelectFiber) =>
           didSelectFiber === true ? selectedFiber : visit(getNextFiber(selectedFiber)),
         );
       }
@@ -261,12 +268,6 @@ export const traverseFiber = ((
   return visit(fiber);
 }) as TraverseFiber;
 
-const isPromiseLike = <Result>(value: unknown): value is PromiseLike<Result> =>
-  (typeof value === "object" || typeof value === "function") &&
-  value !== null &&
-  "then" in value &&
-  typeof value.then === "function";
-
 /**
  * Returns `true` if the {@link Fiber} uses React Compiler's memo cache.
  */
@@ -330,6 +331,7 @@ export const isInstrumentationActive = (target: ReactDevToolsTarget = globalThis
 export const _fiberRoots = new Set<FiberRoot>();
 const rootRendererIds = new WeakMap<FiberRoot, number>();
 const rootHooks = new WeakMap<FiberRoot, ReactDevToolsGlobalHook>();
+let currentUnmountingFiber: Fiber | null = null;
 
 /**
  * Returns the latest fiber (since it may be double-buffered).
@@ -338,7 +340,9 @@ export const getLatestFiber = (fiber: Fiber): Fiber => {
   const alternate = fiber.alternate;
   if (!alternate) return fiber;
   const currentFiber = getCurrentFiberFromRoot(fiber);
-  if (currentFiber) return currentFiber;
+  const isUnmountingPair = fiber === currentUnmountingFiber || alternate === currentUnmountingFiber;
+  if (currentFiber && (!isUnmountingPair || currentFiber === currentUnmountingFiber))
+    return currentFiber;
 
   let rootFiber = fiber;
   while (rootFiber.return) {
@@ -350,6 +354,7 @@ export const getLatestFiber = (fiber: Fiber): Fiber => {
     });
     if (latestFiber) return latestFiber;
   }
+  if (currentFiber) return currentFiber;
 
   if (alternate.actualStartTime && fiber.actualStartTime) {
     return alternate.actualStartTime > fiber.actualStartTime ? alternate : fiber;
@@ -413,14 +418,24 @@ const fiberIdFinalizationRegistry =
 const createFiberReference = (fiber: Fiber): FiberReference =>
   typeof WeakRef === "function" ? new WeakRef(fiber) : { deref: () => fiber };
 
-export const setFiberId = (fiber: Fiber, fiberId: number = nextFiberId++): void => {
+const getNextFiberId = (): number => {
+  if (!Number.isSafeInteger(nextFiberId)) throw new RangeError("Fiber ID space exhausted");
+  return nextFiberId++;
+};
+
+export const setFiberId = (fiber: Fiber, fiberId: number = getNextFiberId()): void => {
   const previousFiberId = fiberIdMap.get(fiber);
-  if (previousFiberId !== undefined && previousFiberId !== fiberId) {
+  if (
+    previousFiberId !== undefined &&
+    previousFiberId !== fiberId &&
+    fiberByIdMap.get(previousFiberId)?.deref() === fiber
+  ) {
     fiberByIdMap.delete(previousFiberId);
   }
   fiberIdMap.set(fiber, fiberId);
   fiberByIdMap.set(fiberId, createFiberReference(fiber));
-  fiberIdFinalizationRegistry?.register(fiber, fiberId);
+  if (previousFiberId !== undefined) fiberIdFinalizationRegistry?.unregister(fiber);
+  fiberIdFinalizationRegistry?.register(fiber, fiberId, fiber);
   if (Number.isSafeInteger(fiberId) && fiberId >= nextFiberId) {
     nextFiberId = fiberId + 1;
   }
@@ -430,10 +445,17 @@ export const getFiberId = (fiber: Fiber): number => {
   let currentFiberId = fiberIdMap.get(fiber);
   if (currentFiberId === undefined && fiber.alternate) {
     currentFiberId = fiberIdMap.get(fiber.alternate);
-    if (currentFiberId !== undefined) setFiberId(fiber, currentFiberId);
+    if (currentFiberId !== undefined) {
+      const assignedFiber = fiberByIdMap.get(currentFiberId)?.deref();
+      if (assignedFiber && assignedFiber !== fiber.alternate) {
+        fiberIdMap.set(fiber, currentFiberId);
+      } else {
+        setFiberId(fiber, currentFiberId);
+      }
+    }
   }
   if (currentFiberId === undefined) {
-    currentFiberId = nextFiberId++;
+    currentFiberId = getNextFiberId();
     setFiberId(fiber, currentFiberId);
   }
   return currentFiberId;
@@ -456,6 +478,7 @@ const releaseFiberId = (fiber: Fiber): void => {
     const fiberId = fiberIdMap.get(relatedFiber);
     if (fiberId !== undefined) fiberIds.add(fiberId);
     fiberIdMap.delete(relatedFiber);
+    fiberIdFinalizationRegistry?.unregister(relatedFiber);
   }
 
   for (const fiberId of fiberIds) {
@@ -532,10 +555,10 @@ const updateFiberTree = (
     if (wasTimedOut && isTimedOut) {
       const nextFallback = fiber.child?.sibling;
       const previousFallback = previousFiber.child?.sibling;
-      if (nextFallback && previousFallback) {
+      if (nextFallback) {
         pendingUpdates.push({
           fiber: nextFallback,
-          previousFiber: previousFallback,
+          previousFiber: previousFallback ?? null,
           traverseSiblings: false,
         });
       }
@@ -606,21 +629,23 @@ const isRootFiberMounted = (fiber: Fiber): boolean => {
  */
 export const traverseRenderedFibers = (root: Fiber | FiberRoot, onRender: RenderHandler): void => {
   const fiber = "current" in root ? root.current : root;
+  const rootKey = "current" in root || !isFiberRoot(root.stateNode) ? root : root.stateNode;
 
-  let rootInstance = rootInstanceMap.get(root);
+  let rootInstance = rootInstanceMap.get(rootKey);
 
   if (!rootInstance) {
     rootInstance = { prevFiber: null };
-    rootInstanceMap.set(root, rootInstance);
+    rootInstanceMap.set(rootKey, rootInstance);
   }
 
   const { prevFiber } = rootInstance;
+  rootInstance.prevFiber = fiber;
   if (!fiber) {
     if (prevFiber) {
       unmountFiber(onRender, prevFiber);
     }
   } else if (prevFiber !== null) {
-    const wasMounted = isRootFiberMounted(prevFiber);
+    const wasMounted = isRootFiberMounted(fiber.alternate ?? prevFiber);
     const isMounted = isRootFiberMounted(fiber);
 
     if (!wasMounted && isMounted) {
@@ -633,8 +658,6 @@ export const traverseRenderedFibers = (root: Fiber | FiberRoot, onRender: Render
   } else {
     mountFiberTree(onRender, fiber, true);
   }
-
-  rootInstance.prevFiber = fiber;
 };
 
 export interface InstrumentationOptions {
@@ -690,10 +713,12 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       priority,
       didError,
     ) => {
+      const isCurrentDispatcher =
+        hookDispatchers.get(rdtHook)?.onCommitFiberRoot === dispatchCommitFiberRoot;
       if (prevOnCommitFiberRoot) {
         callListener(prevOnCommitFiberRoot, rdtHook, rendererID, root, priority, didError);
       }
-      if (hookDispatchers.get(rdtHook)?.onCommitFiberRoot !== dispatchCommitFiberRoot) return;
+      if (!isCurrentDispatcher) return;
       setReactWorkTagsForFiber(root.current, rdtHook.renderers.get(rendererID));
       // Custom renderers and test harnesses commit roots without a memoizedState;
       // those must stay tracked, so only explicit unmount evidence removes a root.
@@ -706,9 +731,14 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
         rootRendererIds.set(root, rendererID);
         rootHooks.set(root, rdtHook);
       }
-      for (const { options, target } of instrumentationSubscriptions) {
-        if (target === hookTargets.get(rdtHook) && options.onCommitFiberRoot) {
-          callListener(options.onCommitFiberRoot, options, rendererID, root, priority, didError);
+      const subscriptionSnapshot = [...instrumentationSubscriptions];
+      for (const subscription of subscriptionSnapshot) {
+        const { options, target } = subscription;
+        if (instrumentationSubscriptions.has(subscription) && target === hookTargets.get(rdtHook)) {
+          callListener(
+            () => options.onCommitFiberRoot?.(rendererID, root, priority, didError),
+            undefined,
+          );
         }
       }
     };
@@ -725,21 +755,29 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       rendererID,
       fiber,
     ) => {
+      const isCurrentDispatcher =
+        hookDispatchers.get(rdtHook)?.onCommitFiberUnmount === dispatchCommitFiberUnmount;
       setReactWorkTagsForFiber(fiber, rdtHook.renderers.get(rendererID));
-      if (prevOnCommitFiberUnmount) {
-        callListener(prevOnCommitFiberUnmount, rdtHook, rendererID, fiber);
-      }
-      if (hookDispatchers.get(rdtHook)?.onCommitFiberUnmount !== dispatchCommitFiberUnmount) {
-        return;
-      }
+      const previousUnmountingFiber = currentUnmountingFiber;
+      currentUnmountingFiber = fiber;
       try {
-        for (const { options, target } of instrumentationSubscriptions) {
-          if (target === hookTargets.get(rdtHook) && options.onCommitFiberUnmount) {
-            callListener(options.onCommitFiberUnmount, options, rendererID, fiber);
+        if (prevOnCommitFiberUnmount) {
+          callListener(prevOnCommitFiberUnmount, rdtHook, rendererID, fiber);
+        }
+        if (!isCurrentDispatcher) return;
+        const subscriptionSnapshot = [...instrumentationSubscriptions];
+        for (const subscription of subscriptionSnapshot) {
+          const { options, target } = subscription;
+          if (
+            instrumentationSubscriptions.has(subscription) &&
+            target === hookTargets.get(rdtHook)
+          ) {
+            callListener(() => options.onCommitFiberUnmount?.(rendererID, fiber), undefined);
           }
         }
       } finally {
-        releaseFiberId(fiber);
+        currentUnmountingFiber = previousUnmountingFiber;
+        if (isCurrentDispatcher) releaseFiberId(fiber);
       }
     };
     dispatchers.onCommitFiberUnmount = dispatchCommitFiberUnmount;
@@ -755,15 +793,17 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       rendererID,
       root,
     ) => {
+      const isCurrentDispatcher =
+        hookDispatchers.get(rdtHook)?.onPostCommitFiberRoot === dispatchPostCommitFiberRoot;
       if (prevOnPostCommitFiberRoot) {
         callListener(prevOnPostCommitFiberRoot, rdtHook, rendererID, root);
       }
-      if (hookDispatchers.get(rdtHook)?.onPostCommitFiberRoot !== dispatchPostCommitFiberRoot) {
-        return;
-      }
-      for (const { options, target } of instrumentationSubscriptions) {
-        if (target === hookTargets.get(rdtHook) && options.onPostCommitFiberRoot) {
-          callListener(options.onPostCommitFiberRoot, options, rendererID, root);
+      if (!isCurrentDispatcher) return;
+      const subscriptionSnapshot = [...instrumentationSubscriptions];
+      for (const subscription of subscriptionSnapshot) {
+        const { options, target } = subscription;
+        if (instrumentationSubscriptions.has(subscription) && target === hookTargets.get(rdtHook)) {
+          callListener(() => options.onPostCommitFiberRoot?.(rendererID, root), undefined);
         }
       }
     };
@@ -781,13 +821,17 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       root,
       children,
     ) => {
+      const isCurrentDispatcher =
+        hookDispatchers.get(rdtHook)?.onScheduleFiberRoot === dispatchScheduleFiberRoot;
       if (prevOnScheduleFiberRoot) {
         callListener(prevOnScheduleFiberRoot, rdtHook, rendererID, root, children);
       }
-      if (hookDispatchers.get(rdtHook)?.onScheduleFiberRoot !== dispatchScheduleFiberRoot) return;
-      for (const { options, target } of instrumentationSubscriptions) {
-        if (target === hookTargets.get(rdtHook) && options.onScheduleFiberRoot) {
-          callListener(options.onScheduleFiberRoot, options, rendererID, root, children);
+      if (!isCurrentDispatcher) return;
+      const subscriptionSnapshot = [...instrumentationSubscriptions];
+      for (const subscription of subscriptionSnapshot) {
+        const { options, target } = subscription;
+        if (instrumentationSubscriptions.has(subscription) && target === hookTargets.get(rdtHook)) {
+          callListener(() => options.onScheduleFiberRoot?.(rendererID, root, children), undefined);
         }
       }
     };
@@ -843,15 +887,20 @@ try {
  */
 export const instrument = (options: InstrumentationOptions): Unsubscribe => {
   const target = options.target ?? globalThis;
-  const rdtHook = getRDTHook(options.onActive, target);
+  const activeListener = options.onActive;
+  const onActive = activeListener ? () => activeListener() : undefined;
+  const existingHook = target.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (existingHook) wireHookEventDispatchers(existingHook, target);
+  const rdtHook = getRDTHook(undefined, target);
   rdtHook._instrumentationSource = options.name ?? BIPPY_INSTRUMENTATION_STRING;
 
   wireHookEventDispatchers(rdtHook, target);
   const subscription: InstrumentationSubscription = { options, target };
   instrumentationSubscriptions.add(subscription);
+  if (onActive) getRDTHook(onActive, target);
 
   return createUnsubscribe(() => {
-    if (options.onActive) removeActiveListener(options.onActive, target);
+    if (onActive) removeActiveListener(onActive, target);
     instrumentationSubscriptions.delete(subscription);
   });
 };
@@ -974,6 +1023,6 @@ export {
   onRendererInject,
   patchRDTHook,
   version,
-} from "./rdt-hook.js";
-export type { ReactDevToolsTarget, Unsubscribe } from "./rdt-hook.js";
-export * from "./react-internals/index.js";
+} from "./rdt-hook";
+export type { ReactDevToolsTarget, Unsubscribe } from "./rdt-hook";
+export * from "./react-internals/index";

package/src/index.ts

@@ -1,4 +1,4 @@
-import "./install-hook-only.js";
+import "./install-hook-only";
 
-export * from "./core.js";
-export * from "./react.js";
+export * from "./core";
+export * from "./react";

package/src/install-hook-only.ts

@@ -1,4 +1,4 @@
-import { getRDTHook } from "./rdt-hook.js";
+import { getRDTHook } from "./rdt-hook";
 
 // Importing bippy must never crash module evaluation, even when a foreign
 // hook is frozen or otherwise rejects patching.

package/src/rdt-hook.ts

@@ -1,7 +1,7 @@
 // This module must load before React so renderers can inject into the hook.
 
-import { callListener } from "./call-listener.js";
-import type { FiberRoot, ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
+import { callListener } from "./call-listener";
+import type { FiberRoot, ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index";
 
 export interface Unsubscribe extends Disposable {
   (): void;
@@ -24,6 +24,10 @@ interface RDTHookReplaceListener {
   (rdtHook: ReactDevToolsGlobalHook, target: ReactDevToolsTarget): void;
 }
 
+interface RDTHookReplaceSubscription {
+  listener: RDTHookReplaceListener;
+}
+
 export interface ReactDevToolsTarget {
   __REACT_DEVTOOLS_GLOBAL_HOOK__?: ReactDevToolsGlobalHook;
 }
@@ -94,7 +98,7 @@ export const _renderers = new Set<ReactRenderer>();
 
 const activeListenerTargets = new WeakMap<ActiveListener, Set<ReactDevToolsTarget>>();
 const rendererInjectSubscriptions = new Set<RendererInjectSubscription>();
-const rdtHookReplaceListeners = new Set<RDTHookReplaceListener>();
+const rdtHookReplaceSubscriptions = new Set<RDTHookReplaceSubscription>();
 const notifiedRenderersByTarget = new WeakMap<ReactDevToolsTarget, WeakSet<ReactRenderer>>();
 
 const addActiveListener = (listener: ActiveListener, target: ReactDevToolsTarget): void => {
@@ -116,8 +120,11 @@ export const removeActiveListener = (
   }
 };
 
-const notifyActiveListeners = (target: ReactDevToolsTarget): void => {
-  for (const listener of _onActiveListeners) {
+const notifyActiveListeners = (
+  target: ReactDevToolsTarget,
+  pendingListeners = [..._onActiveListeners],
+): void => {
+  for (const listener of pendingListeners) {
     if (activeListenerTargets.get(listener)?.has(target)) callListener(listener, undefined);
   }
 };
@@ -126,8 +133,11 @@ const notifyRendererInjectListeners = (
   target: ReactDevToolsTarget,
   renderer: ReactRenderer,
 ): void => {
-  for (const subscription of rendererInjectSubscriptions) {
-    if (subscription.target === target) callListener(subscription.listener, subscription, renderer);
+  const subscriptionSnapshot = [...rendererInjectSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rendererInjectSubscriptions.has(subscription) && subscription.target === target) {
+      callListener(subscription.listener, subscription, renderer);
+    }
   }
 };
 
@@ -135,8 +145,11 @@ const notifyRDTHookReplaceListeners = (
   rdtHook: ReactDevToolsGlobalHook,
   target: ReactDevToolsTarget,
 ): void => {
-  for (const listener of rdtHookReplaceListeners) {
-    callListener(listener, undefined, rdtHook, target);
+  const subscriptionSnapshot = [...rdtHookReplaceSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rdtHookReplaceSubscriptions.has(subscription)) {
+      callListener(subscription.listener, undefined, rdtHook, target);
+    }
   }
 };
 
@@ -153,9 +166,10 @@ export const onRendererInject = (
 };
 
 export const onRDTHookReplace = (listener: RDTHookReplaceListener): Unsubscribe => {
-  rdtHookReplaceListeners.add(listener);
+  const subscription = { listener };
+  rdtHookReplaceSubscriptions.add(subscription);
   return createUnsubscribe(() => {
-    rdtHookReplaceListeners.delete(listener);
+    rdtHookReplaceSubscriptions.delete(subscription);
   });
 };
 
@@ -243,10 +257,11 @@ export const installRDTHook = (
             _renderers.add(renderer);
             nextRenderers.set(rendererId, renderer);
           });
-          if (ourRenderers.size > 0 || rdtHookReplaceListeners.size > 0) {
-            patchRDTHook(onActive, target);
+          if (ourRenderers.size > 0 || rdtHookReplaceSubscriptions.size > 0) {
+            patchRDTHook(undefined, target, () => notifyRDTHookReplaceListeners(newHook, target));
+          } else {
+            notifyRDTHookReplaceListeners(newHook, target);
           }
-          notifyRDTHookReplaceListeners(rdtHook, target);
         }
       },
     });
@@ -288,9 +303,10 @@ export const installRDTHook = (
 export const patchRDTHook = (
   onActive?: ActiveListener,
   target: ReactDevToolsTarget = globalThis,
+  onReady?: () => void,
 ): void => {
   if (onActive) addActiveListener(onActive, target);
-  let didNotifyActiveListeners = false;
+  let shouldNotifyActiveListeners = false;
   const rdtHook = getTargetHook(target);
   if (!rdtHook) return;
   const renderers = getRendererMap(rdtHook);
@@ -306,28 +322,25 @@ export const patchRDTHook = (
     if (!isReactDevtools) {
       rdtHook.on = noOp;
     }
-    if (renderers.size) {
-      renderers.forEach((renderer) => _renderers.add(renderer));
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners(target);
-      didNotifyActiveListeners = true;
-    } else if (!isReactDevtools && isReactRefresh(rdtHook)) {
-      // HACK: react-refresh's stub inject never records renderers, so a React app
-      // that injected before bippy loaded is undetectable through the renderers map.
-      // A react-refresh hook implies a dev renderer, so activate immediately.
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners(target);
-      didNotifyActiveListeners = true;
-    }
+    const shouldActivate = renderers.size > 0 || (!isReactDevtools && isReactRefresh(rdtHook));
     const previousInject = rdtHook.inject;
     rdtHook.inject = (renderer) => {
       const rendererId = previousInject.call(rdtHook, renderer);
       trackInjectedRenderer(rdtHook, target, renderers, rendererId, renderer);
       return rendererId;
     };
+    if (shouldActivate) {
+      renderers.forEach((renderer) => _renderers.add(renderer));
+      rdtHook._instrumentationIsActive = true;
+      shouldNotifyActiveListeners = true;
+    }
   }
-  if (!didNotifyActiveListeners && (renderers.size || rdtHook._instrumentationIsActive)) {
-    if (onActive) callListener(onActive, undefined);
+  const pendingListeners = shouldNotifyActiveListeners ? [..._onActiveListeners] : [];
+  onReady?.();
+  if (shouldNotifyActiveListeners) {
+    notifyActiveListeners(target, pendingListeners);
+  } else if (onActive && (renderers.size || rdtHook._instrumentationIsActive)) {
+    callListener(onActive, undefined);
   }
 };
 

package/src/react-internals/current-fiber.ts

@@ -1,6 +1,6 @@
 // Adapted from ReactFiberTreeReflection.js. Copyright (c) Meta Platforms, Inc. and affiliates. MIT licensed.
-import type { Fiber } from "./types.js";
-import { getReactWorkTagsForFiber } from "./index.js";
+import type { Fiber } from "./types";
+import { getReactWorkTagsForFiber } from "./index";
 
 export const getCurrentFiberFromRoot = (fiber: Fiber): Fiber | null => {
   const alternate = fiber.alternate;

package/src/react-internals/generated/react-work-tags.ts

@@ -1,4 +1,4 @@
-import { compareSemver } from "../semver.js";
+import { compareSemver } from "../semver";
 
 export const ReactBuildType = {
   Development: 1,

package/src/react-internals/index.ts

@@ -1,22 +1,22 @@
-import { getReactWorkTags, ReactFiberFlags } from "./generated/react-work-tags.js";
-import type { ReactWorkTagMap } from "./generated/react-work-tags.js";
-import { isSemver } from "./semver.js";
-import type { Fiber, ReactRenderer } from "./types.js";
+import { getReactWorkTags, ReactFiberFlags } from "./generated/react-work-tags";
+import type { ReactWorkTagMap } from "./generated/react-work-tags";
+import { isSemver } from "./semver";
+import type { Fiber, ReactRenderer } from "./types";
 
-export { compareSemver } from "./semver.js";
+export { compareSemver } from "./semver";
 export {
   getReactWorkTags,
   ReactBuildType,
   ReactFiberFlags,
   ReactSymbols,
-} from "./generated/react-work-tags.js";
+} from "./generated/react-work-tags";
 export type {
   HostWorkTag,
   ReactWorkTag,
   ReactWorkTagMap,
   ReactWorkTagVersion,
-} from "./generated/react-work-tags.js";
-export * from "./types.js";
+} from "./generated/react-work-tags";
+export * from "./types";
 
 interface InheritedWorkTags {
   workTags: Readonly<ReactWorkTagMap>;

package/src/react-internals/types.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from "react";
 import type ReactReconciler from "react-reconciler";
-import type { HostWorkTag, ReactWorkTag } from "./generated/react-work-tags.js";
+import type { HostWorkTag, ReactWorkTag } from "./generated/react-work-tags";
 
 export type WorkTag = ReactReconciler.WorkTag | ReactWorkTag;
 

package/src/react.ts

@@ -1,11 +1,11 @@
-import "./install-hook-only.js";
+import "./install-hook-only";
 import React from "react";
-import { isFiber, traverseFiber } from "./core.js";
-import { _renderers } from "./rdt-hook.js";
-import { getCurrentFiberFromRoot } from "./react-internals/current-fiber.js";
-import type { Fiber } from "./react-internals/index.js";
+import { isFiber, traverseFiber } from "./core";
+import { _renderers } from "./rdt-hook";
+import { getCurrentFiberFromRoot } from "./react-internals/current-fiber";
+import type { Fiber } from "./react-internals/index";
 
-export type { Fiber } from "./react-internals/index.js";
+export type { Fiber } from "./react-internals/index";
 
 interface RenderMarker {
   (state: undefined): undefined;

package/src/source/constants.ts

@@ -1,15 +1,19 @@
 export const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
 
 export const INTERNAL_SCHEME_PREFIXES = [
-  "rsc://",
-  "file:///",
+  "rspack-internal://",
   "webpack-internal://",
-  "webpack://",
-  "node:",
   "turbopack://",
+  "webpack://",
+  "rspack://",
+  "parcel://",
   "metro://",
-  "/app-pages-browser/",
+  "file:///",
+  "rsc://",
+  "node:",
+  "bun:",
   "/(app-pages-browser)/",
+  "/app-pages-browser/",
 ] as const;
 
 export const ABOUT_REACT_PREFIX = "about://React/";
@@ -21,7 +25,7 @@ export const ANONYMOUS_FILE_PATTERNS = ["<anonymous>", "eval", ""] as const;
 export const SOURCE_FILE_EXTENSION_REGEX = /\.(cjs|cts|js|jsx|mdx|mjs|mts|ts|tsx)$/;
 
 export const BUNDLED_FILE_PATTERN_REGEX =
-  /(\.min|bundle|chunk|vendor|vendors|runtime|polyfill|polyfills)\.(js|mjs|cjs)$|(chunk|bundle|vendor|vendors|runtime|polyfill|polyfills|framework|app|main|index)[-_.][A-Za-z0-9_-]{4,}\.(js|mjs|cjs)$|[\da-f]{8,}\.(js|mjs|cjs)$|[-_.][\da-f]{20,}\.(js|mjs|cjs)$|\/dist\/|\/build\/|\/.next\/|\/out\/|\/node_modules\/|\.webpack\.|\.vite\.|\.turbopack\./i;
+  /(\.min|bundle|chunk|vendor|vendors|runtime|polyfill|polyfills)\.(js|mjs|cjs)$|(chunk|bundle|vendor|vendors|runtime|polyfill|polyfills|framework|app|main|index)[-_.][A-Za-z0-9_-]{4,}\.(js|mjs|cjs)$|[\da-f]{8,}\.(js|mjs|cjs)$|[-_.][\da-f]{20,}\.(js|mjs|cjs)$|\/dist\/|\/build\/|\/.next\/|\/out\/|\/node_modules\/|\/_next\/|\/_expo\/|\/_nuxt\/|\/@vite\/|\/@react-refresh|\/\.parcel-cache\/|\/\.expo\/|\/\.rsbuild\/|\/\.vite\/|\/\.svelte-kit\/|\/\.astro\/|\/\.nuxt\/|\/\.angular\/|\.webpack\.|\.vite\.|\.turbopack\.|\[root-of-the-server\]/i;
 
 export const QUERY_PARAMETER_PATTERN_REGEX = /^\?[\w~.-]+(?:=[^&#]*)?(?:&[\w~.-]+(?:=[^&#]*)?)*$/;
 

package/src/source/get-display-name-from-source.ts

@@ -1,14 +1,14 @@
-import type { Fiber } from "../react-internals/index.js";
-import { getDisplayName } from "../core.js";
-import { getDefinitionFrameFromOwnedChild, getRawParentStack } from "./owner-stack.js";
+import type { Fiber } from "../react-internals/index";
+import { getDisplayName } from "../core";
+import { getDefinitionFrameFromOwnedChild, getRawParentStack } from "./owner-stack";
 import {
   getSourceContentFromSourceMap,
   getSourceFromSourceMap,
   getSourceMap,
   type SourceFetch,
   type SourceMapRequestOptions,
-} from "./symbolication.js";
-import type { StackFrame } from "./parse-stack.js";
+} from "./symbolication";
+import type { StackFrame } from "./parse-stack";
 
 const COMPONENT_DECLARATION_PATTERNS = [
   /(?:^|export\s+)(?:const|let|var)\s+(\w+)\s*=/,