@reckona/mreact-compat 0.0.160 → 0.0.161

package/src/class-component.ts

@@ -1,4 +1,4 @@
-import { renderWithRootRuntime, useLayoutEffect, useRef, type RootRuntime } from "./hooks.js";
+import { renderWithRootRuntime, scheduleRuntimeRerender, useLayoutEffect, useRef, type RootRuntime } from "./hooks.js";
 import { isReactCompatElement, type ReactCompatElement, type ReactCompatNode } from "./element.js";
 import { withHydrationComponentStack, type RenderOptions } from "./hydration.js";
 import type { ReconcileNode, ReconcileResult } from "./reconcile-types.js";
@@ -48,6 +48,7 @@ export interface ClassComponentType {
   getDerivedStateFromError?: (error: Error) => Record<string, unknown> | null;
 }
 
+/** Base class-style component contract with state updates and render lifecycle. */
 export interface Component<
   P extends Record<string, unknown> = Record<string, unknown>,
   S extends Record<string, unknown> = Record<string, unknown>,
@@ -79,6 +80,7 @@ export interface ComponentConstructor {
   prototype: Component<any, any>;
 }
 
+/** Base class-style component constructor for React-compatible class components. */
 export const Component: ComponentConstructor = function Component<
   P extends Record<string, unknown> = Record<string, unknown>,
   S extends Record<string, unknown> = Record<string, unknown>,
@@ -117,6 +119,7 @@ Component.prototype.render = function render(): ReactCompatNode {
   return null;
 };
 
+/** Class-style component contract that skips updates for shallow-equal props and state. */
 export interface PureComponent<
   P extends Record<string, unknown> = Record<string, unknown>,
   S extends Record<string, unknown> = Record<string, unknown>,
@@ -136,6 +139,7 @@ export interface PureComponentConstructor {
   prototype: PureComponent<any, any>;
 }
 
+/** Class-style component constructor with shallow prop and state comparison. */
 export const PureComponent: PureComponentConstructor = function PureComponent<
   P extends Record<string, unknown> = Record<string, unknown>,
   S extends Record<string, unknown> = Record<string, unknown>,
@@ -164,6 +168,7 @@ interface ClassLifecycleSnapshot {
   nextState?: Record<string, unknown>;
   force?: boolean;
   snapshot?: unknown;
+  callbacks?: (() => void)[];
 }
 
 interface ClassUpdateContext {
@@ -265,6 +270,7 @@ export function renderClassComponentWithRuntime(
   options: {
     currentInstance?: ClassComponentInstance;
     hasDirtyDescendant?: boolean;
+    allowSkip?: boolean;
   } = {},
 ): ClassComponentRenderResult {
   return renderWithRootRuntime(runtime, path, () => {
@@ -315,6 +321,7 @@ export function renderClassComponentWithRuntime(
       didCommitRef.current &&
       snapshot?.force !== true &&
       options.hasDirtyDescendant !== true &&
+      options.allowSkip !== false &&
       instance.shouldComponentUpdate?.(props, nextState) === false;
 
     instance.props = props;
@@ -538,14 +545,17 @@ function enqueueClassSetState(
           ...nextPartial,
         };
 
-  classLifecycleSnapshots.set(instance, {
+  const nextSnapshot: ClassLifecycleSnapshot = {
     ...snapshot,
     previousState,
     nextState,
-  });
+  };
+  if (callback !== undefined) {
+    nextSnapshot.callbacks = [...(snapshot?.callbacks ?? []), callback.bind(instance)];
+  }
+  classLifecycleSnapshots.set(instance, nextSnapshot);
 
   markClassInstanceDirty(instance, updateContext);
-  callback?.call(instance);
 }
 
 function enqueueClassForceUpdate(
@@ -559,12 +569,17 @@ function enqueueClassForceUpdate(
     return;
   }
 
-  classLifecycleSnapshots.set(instance, {
+  const snapshot = classLifecycleSnapshots.get(instance);
+  const nextSnapshot: ClassLifecycleSnapshot = {
+    ...snapshot,
     previousState: instance.state ?? {},
     force: true,
-  });
+  };
+  if (callback !== undefined) {
+    nextSnapshot.callbacks = [...(snapshot?.callbacks ?? []), callback.bind(instance)];
+  }
+  classLifecycleSnapshots.set(instance, nextSnapshot);
   markClassInstanceDirty(instance, updateContext);
-  callback?.call(instance);
 }
 
 function markClassInstanceDirty(
@@ -578,7 +593,7 @@ function markClassInstanceDirty(
   if (runtimeInstance !== undefined) {
     runtimeInstance.dirty = true;
   }
-  updateContext.runtime.rerender();
+  scheduleRuntimeRerender(updateContext.runtime);
 }
 
 export function hasDirtyClassUpdate(
@@ -660,13 +675,16 @@ function installClassLifecycleEffects(
   replacedInstance?: ClassComponentInstance,
 ): void {
   useLayoutEffect(() => {
+    const lifecycleSnapshot = classLifecycleSnapshots.get(instance);
+
     if (replacedInstance !== undefined) {
       replacedInstance.componentWillUnmount?.();
       classUpdateContexts.delete(replacedInstance);
     }
 
     if (skipUpdate) {
-      classLifecycleSnapshots.delete(instance);
+      runClassUpdateCallbacks(lifecycleSnapshot);
+      deleteClassLifecycleSnapshotIfCurrent(instance, lifecycleSnapshot);
       return;
     }
 
@@ -674,14 +692,15 @@ function installClassLifecycleEffects(
       instance.componentDidUpdate?.(
         previousProps ?? {},
         previousState,
-        classLifecycleSnapshots.get(instance)?.snapshot,
+        lifecycleSnapshot?.snapshot,
       );
     } else {
       didCommitRef.current = true;
       instance.componentDidMount?.();
     }
 
-    classLifecycleSnapshots.delete(instance);
+    runClassUpdateCallbacks(lifecycleSnapshot);
+    deleteClassLifecycleSnapshotIfCurrent(instance, lifecycleSnapshot);
   });
 
   useLayoutEffect(() => {
@@ -693,6 +712,23 @@ function installClassLifecycleEffects(
   }, []);
 }
 
+function runClassUpdateCallbacks(snapshot: ClassLifecycleSnapshot | undefined): void {
+  const callbacks = snapshot?.callbacks ?? [];
+
+  for (const callback of callbacks) {
+    callback();
+  }
+}
+
+function deleteClassLifecycleSnapshotIfCurrent(
+  instance: ClassComponentInstance,
+  snapshot: ClassLifecycleSnapshot | undefined,
+): void {
+  if (classLifecycleSnapshots.get(instance) === snapshot) {
+    classLifecycleSnapshots.delete(instance);
+  }
+}
+
 function isErrorBoundaryClass(
   type: ClassComponentType,
   instance: ClassComponentInstance,

package/src/context.ts

@@ -53,6 +53,7 @@ const contextReadObserverState =
     current: undefined,
   });
 
+/** Creates a context object with Provider and Consumer entries. */
 export function createContext<T>(defaultValue: T): ReactCompatContext<T> {
   const context: ReactCompatContext<T> = {
     defaultValue,
@@ -94,6 +95,7 @@ function installContextDisplayName<T>(context: ReactCompatContext<T>): void {
   });
 }
 
+/** Reads the current value for a React-compatible context. */
 export function useContext<T>(context: ReactCompatContextLike<T>): T {
   const value = readContextValue(context);
   contextReadObserverState.current?.(context as ReactCompatContextLike<unknown>, value);
@@ -213,6 +215,7 @@ export function popContextProvider<T>(provider: ReactCompatProvider<T>): void {
   externalContextValues.get(context)?.pop();
 }
 
+/** Renders a string while a provider value is active. */
 export function renderContextProviderToString<T>(
   provider: ReactCompatProvider<T>,
   value: T,
@@ -221,6 +224,7 @@ export function renderContextProviderToString<T>(
   return renderWithContextProvider(provider, value, render);
 }
 
+/** Renders a string with the current value from a context consumer. */
 export function renderContextConsumerToString<T>(
   consumer: ReactCompatConsumer<T>,
   render: (value: T) => string,

package/src/element.ts

@@ -6,14 +6,20 @@ export const LAZY_TYPE = Symbol.for("react.lazy");
 export const STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
 export const PORTAL_TYPE = Symbol.for("react.portal");
 const REACT_COMPAT_PROVIDER_TYPE = Symbol.for("react.context");
+/** Symbol used to group JSX children without adding a host element. */
 export const Fragment = Symbol.for("react.fragment");
+/** Symbol used to suspend rendering while async content resolves. */
 export const Suspense = Symbol.for("react.suspense");
+/** Symbol used to coordinate multiple suspense boundaries. */
 export const SuspenseList = Symbol.for("react.suspense_list");
+/** Symbol used to mark activity boundaries in React-compatible trees. */
 export const Activity = Symbol.for("react.activity");
+/** Symbol used to measure render work with profiler callbacks. */
 export const Profiler = Symbol.for("react.profiler");
 export const HOST_CHILDREN_ONLY_PROPS_META = Symbol.for(
   "modular.react.host_children_only_props_meta",
 );
+/** Metadata key that links a state value to a reactive text binding. */
 export const REACTIVE_TEXT_BINDING_META = Symbol.for(
   "modular.react.reactive_text_binding_meta",
 );
@@ -29,6 +35,7 @@ export interface ReactCompatContextProviderShorthand {
   Consumer: unknown;
 }
 
+/** Element type accepted by createElement, JSX, and renderer entrypoints. */
 export type ElementType<P = Record<string, unknown>> =
   | string
   | typeof Fragment
@@ -46,6 +53,7 @@ export type ElementType<P = Record<string, unknown>> =
   | ((props: P) => ReactCompatNode | PromiseLike<ReactCompatNode>)
   | (new (props: P) => { render(): ReactCompatNode });
 
+/** Renderable value accepted by the React-compatible renderer. */
 export type ReactCompatNode =
   | ReactCompatElement
   | ReactCompatPortal
@@ -56,6 +64,7 @@ export type ReactCompatNode =
   | undefined
   | ReactCompatNode[];
 
+/** React-compatible element record produced by createElement and JSX transforms. */
 export interface ReactCompatElement<P = Record<string, unknown>> {
   $$typeof: typeof REACT_COMPAT_ELEMENT_TYPE;
   type: ElementType<P>;
@@ -64,6 +73,7 @@ export interface ReactCompatElement<P = Record<string, unknown>> {
   props: P & { children?: ReactCompatNode };
 }
 
+/** Portal record that renders children into an external DOM container. */
 export interface ReactCompatPortal {
   $$typeof: typeof PORTAL_TYPE;
   container: Element;
@@ -71,6 +81,7 @@ export interface ReactCompatPortal {
   key: string | null;
 }
 
+/** Creates a React-compatible element from a type, config object, and children. */
 export function createElement<P extends Record<string, unknown>>(
   type: ElementType<P>,
   config: (P & ReactReservedProps) | null,
@@ -125,6 +136,7 @@ export function createElement<P extends Record<string, unknown>>(
   };
 }
 
+/** Creates a React-compatible element from JSX runtime arguments. */
 export function createElementFromJsxConfig<P extends Record<string, unknown>>(
   type: ElementType<P>,
   config: (P & ReactReservedProps & { children?: ReactCompatNode }) | null,
@@ -142,8 +154,8 @@ export function createElementFromJsxConfig<P extends Record<string, unknown>>(
   const props = (typeof normalizedType === "string"
     ? copiedProps
     : applyDefaultProps(normalizedType, copiedProps)) as P & {
-      children?: ReactCompatNode;
-    };
+    children?: ReactCompatNode;
+  };
 
   if (hasChildren) {
     props.children = children;
@@ -162,6 +174,7 @@ export function createElementFromJsxConfig<P extends Record<string, unknown>>(
   };
 }
 
+/** Returns true when a value is a React-compatible element record. */
 export function isReactCompatElement(
   value: unknown,
 ): value is ReactCompatElement {
@@ -172,6 +185,7 @@ export function isReactCompatElement(
   );
 }
 
+/** Creates a portal that renders children into a DOM container outside the parent tree. */
 export function createPortal(
   children: ReactCompatNode,
   container: Element,
@@ -185,6 +199,7 @@ export function createPortal(
   };
 }
 
+/** Returns true when a value is a React-compatible portal record. */
 export function isReactCompatPortal(value: unknown): value is ReactCompatPortal {
   return (
     typeof value === "object" &&
@@ -193,21 +208,25 @@ export function isReactCompatPortal(value: unknown): value is ReactCompatPortal
   );
 }
 
+/** Creates a mutable ref object with a null initial current value. */
 export function createRef<T>(): { current: T | null } {
   return { current: null };
 }
 
+/** Element type record produced by forwardRef. */
 export interface ForwardRefType<P = Record<string, unknown>> {
   $$typeof: typeof FORWARD_REF_TYPE;
   render: (props: P, ref: unknown) => ReactCompatNode;
 }
 
+/** Element type record produced by memo. */
 export interface MemoType<P = Record<string, unknown>> {
   $$typeof: typeof MEMO_TYPE;
   type: ElementType<P>;
   compare?: (previous: P, next: P) => boolean;
 }
 
+/** Element type record produced by lazy. */
 export interface LazyType<P = Record<string, unknown>> {
   $$typeof: typeof LAZY_TYPE;
   load: () => Promise<{ default: ElementType<P> }>;
@@ -217,12 +236,14 @@ export interface LazyType<P = Record<string, unknown>> {
   error?: unknown;
 }
 
+/** Wraps a component so it can receive a ref as the second render argument. */
 export function forwardRef<P, T>(
   render: (props: P, ref: { current: T | null } | ((value: T | null) => void) | null) => ReactCompatNode,
 ): ForwardRefType<P & { ref?: unknown }> {
   return { $$typeof: FORWARD_REF_TYPE, render: render as ForwardRefType<P>["render"] };
 }
 
+/** Wraps an element type with optional prop comparison for memoized renders. */
 export function memo<P>(
   type: ElementType<P>,
   compare?: (previous: P, next: P) => boolean,
@@ -232,6 +253,7 @@ export function memo<P>(
     : { $$typeof: MEMO_TYPE, type, compare };
 }
 
+/** Creates a lazy element type that resolves its implementation on demand. */
 export function lazy<P>(
   load: () => Promise<{ default: ElementType<P> }>,
 ): LazyType<P> {
@@ -242,8 +264,10 @@ export function lazy<P>(
   };
 }
 
+/** Symbol used to mark a subtree for strict-mode development checks. */
 export const StrictMode = STRICT_MODE_TYPE;
 
+/** Clones an existing element with merged props and optional replacement children. */
 export function cloneElement<P extends Record<string, unknown>>(
   element: ReactCompatElement<P>,
   props: Partial<P> | null,
@@ -251,10 +275,9 @@ export function cloneElement<P extends Record<string, unknown>>(
 ): ReactCompatElement<P> {
   const key = props === null || props.key === undefined ? element.key : String(props.key);
   const ref = props === null || props.ref === undefined ? element.ref : props.ref;
-  const nextProps = applyDefaultProps(
-    element.type,
-    copyElementProps(props, element.props),
-  ) as P & { children?: ReactCompatNode };
+  const nextProps = copyElementProps(props, element.props) as P & {
+    children?: ReactCompatNode;
+  };
 
   if (children.length === 1) {
     (nextProps as P & { children?: ReactCompatNode }).children = children[0];
@@ -392,8 +415,10 @@ function hostPropsAreChildrenOnly(props: Record<string, unknown>): boolean {
   return true;
 }
 
+/** Alias for checking whether a value is a React-compatible element. */
 export const isValidElement = isReactCompatElement;
 
+/** Helpers for iterating, counting, flattening, and validating children. */
 export const Children = {
   map<T>(
     children: ReactCompatNode,
@@ -453,11 +478,13 @@ function flattenChildren(children: ReactCompatNode): ReactCompatNode[] {
   return [children];
 }
 
+/** Options used to render and observe a React-compatible error boundary. */
 export interface ErrorBoundaryOptions {
   fallback: (error: Error) => ReactCompatNode;
   onError?: (error: Error) => void;
 }
 
+/** Creates an error boundary element with a fallback renderer. */
 export function createErrorBoundary(
   options: ErrorBoundaryOptions,
   children: ReactCompatNode,

package/src/event-priority.ts

@@ -1 +1,2 @@
+/** Event priority helpers for React-compatible event batching. */
 export { runWithEventPriority, type EventPriority } from "./hooks.js";

package/src/event-replay.ts

@@ -2,11 +2,13 @@ const queuedHydrationEvents = new WeakMap<Element, QueuedHydrationEvent[]>();
 const replayedEvents = new WeakSet<Event>();
 const allowedReplayEventTypes = new Set(["click", "input", "change", "submit"]);
 
+/** Serialized map of server-rendered event handlers used for hydration replay. */
 export interface EventHydrationManifest {
   version: 1;
   events: EventHydrationManifestEntry[];
 }
 
+/** Single event handler entry in a hydration replay manifest. */
 export interface EventHydrationManifestEntry {
   id: string;
   event: string;
@@ -22,6 +24,7 @@ export interface HydrationEventReplayOptions {
   onCapturedEvent?: (event: Event, target: EventTarget) => void;
 }
 
+/** Queues a captured event so it can be replayed after hydration. */
 export function queueHydrationEvent(
   container: Element,
   event: Event,
@@ -40,10 +43,12 @@ export function queueHydrationEvent(
   queuedHydrationEvents.set(container, events);
 }
 
+/** Captures supported events on a container until hydration can replay them. */
 export function enableHydrationEventReplay(container: Element): () => void {
   return enableHydrationEventReplayForTypes(container, allowedReplayEventTypes);
 }
 
+/** Reads an event hydration manifest script from a document or parent node. */
 export function readEventHydrationManifest(
   root: ParentNode = document,
 ): EventHydrationManifest | undefined {
@@ -64,6 +69,7 @@ export function readEventHydrationManifest(
   return value;
 }
 
+/** Captures only the event types declared by a hydration manifest. */
 export function enableEventHydrationManifestReplay(
   container: Element,
   manifest: EventHydrationManifest | undefined,

package/src/flight-decoder.ts

@@ -11,6 +11,7 @@ import type {
   FlightTypedArrayName,
 } from "./flight-types.js";
 
+/** Options used when resolving client and server references while decoding Flight models. */
 export interface DecodeFlightOptions {
   loadClientReference(reference: FlightClientReference): ElementType<Record<string, unknown>>;
   callServerReference?(

package/src/flight-protocol.ts

@@ -56,12 +56,14 @@ export const reactFlightModelTokens = [
 
 export type ReactFlightBinaryRowTag = (typeof reactFlightBinaryRowTags)[number];
 
+/** Lists the React Flight row tags and model tokens recognized by this package. */
 export interface ReactFlightProtocolCoverage {
   binaryRowTags: string[];
   modelTokens: string[];
   rowTags: string[];
 }
 
+/** Returns the React Flight protocol markers currently covered by the decoder. */
 export function getReactFlightProtocolCoverage(): ReactFlightProtocolCoverage {
   return {
     binaryRowTags: [...reactFlightBinaryRowTags],

package/src/flight-types.ts

@@ -1,3 +1,4 @@
+/** Client module reference carried by a Flight response. */
 export interface FlightClientReference {
   id: number;
   moduleId: string;
@@ -5,6 +6,7 @@ export interface FlightClientReference {
   chunks?: string[];
 }
 
+/** Server action reference carried by a Flight response. */
 export interface FlightServerReference {
   id: number;
   moduleId: string;
@@ -12,6 +14,7 @@ export interface FlightServerReference {
   bound?: FlightModel[];
 }
 
+/** Parsed React Flight response with root model and reference tables. */
 export interface FlightResponse {
   version: 1;
   root: FlightModel;
@@ -19,6 +22,7 @@ export interface FlightResponse {
   serverReferences: FlightServerReference[];
 }
 
+/** Serializable model value supported by the mreact Flight decoder. */
 export type FlightModel =
   | null
   | string
@@ -49,6 +53,7 @@ export interface FlightObjectModel {
   [key: string]: FlightModel | undefined;
 }
 
+/** Flight model record for a rendered element. */
 export interface FlightElementModel {
   kind: "element";
   type: string | FlightClientReferenceModel | { kind: "fragment" };
@@ -56,56 +61,67 @@ export interface FlightElementModel {
   props: Record<string, FlightModel>;
 }
 
+/** Flight model record that points at a client reference table entry. */
 export interface FlightClientReferenceModel {
   kind: "client-reference";
   id: number;
 }
 
+/** Flight model record that points at a server reference table entry. */
 export interface FlightServerReferenceModel {
   kind: "server-reference";
   id: number;
 }
 
+/** Flight model record for a Date value. */
 export interface FlightDateModel {
   kind: "date";
   value: string;
 }
 
+/** Flight model record for a bigint value. */
 export interface FlightBigIntModel {
   kind: "bigint";
   value: string;
 }
 
+/** Flight model record for non-finite or negative-zero numbers. */
 export interface FlightNumberModel {
   kind: "number";
   value: "Infinity" | "-Infinity" | "NaN" | "-0";
 }
 
+/** Flight model record for a global symbol. */
 export interface FlightSymbolModel {
   kind: "symbol";
   name: string;
 }
 
+/** Flight model record for a Map value. */
 export interface FlightMapModel {
   kind: "map";
   entries: [FlightModel, FlightModel][];
 }
 
+/** Flight model record for a Set value. */
 export interface FlightSetModel {
   kind: "set";
   values: FlightModel[];
 }
 
+/** Flight model record for a FormData value. */
 export interface FlightFormDataModel {
   kind: "form-data";
   entries: [string, FlightModel][];
 }
 
+/** Flight model record for an iterable value encoded as an array. */
 export interface FlightIterableModel {
   kind: "iterable";
   values: FlightModel[];
 }
 
+/** Flight model record for an error thrown while decoding. */
 export interface FlightErrorModel {
   kind: "error";
   name: string;
@@ -113,27 +129,32 @@ export interface FlightErrorModel {
   digest?: string;
 }
 
+/** Flight model record for a pending promise chunk. */
 export interface FlightPromiseModel {
   kind: "promise";
   id: number;
 }
 
+/** Flight model record for an ArrayBuffer value. */
 export interface FlightArrayBufferModel {
   kind: "array-buffer";
   bytes: number[];
 }
 
+/** Flight model record for a typed array value. */
 export interface FlightTypedArrayModel {
   kind: "typed-array";
   arrayType: FlightTypedArrayName;
   bytes: number[];
 }
 
+/** Flight model record for a DataView value. */
 export interface FlightDataViewModel {
   kind: "data-view";
   bytes: number[];
 }
 
+/** Typed array constructor names supported by the Flight decoder. */
 export type FlightTypedArrayName =
   | "Int8Array"
   | "Uint8Array"

package/src/flight.ts

@@ -57,6 +57,7 @@ export type {
 };
 export type { ReactFlightProtocolCoverage };
 
+/** Options for creating a fetch-based server reference caller. */
 export interface FetchServerReferenceCallerOptions {
   fetch?: typeof fetch;
   headers?: Record<string, string>;
@@ -67,14 +68,17 @@ export interface FetchServerReferenceCallerOptions {
   nonce?: string | (() => string);
 }
 
+/** Options for decoding a Flight response and hydrating it into a DOM container. */
 export interface HydrateFlightOptions extends DecodeFlightOptions {
   hydrate?: HydrateRootOptions;
 }
 
+/** Parses a serialized Flight payload into a Flight response object. */
 export function parseFlightResponse(payload: string | ArrayBuffer | Uint8Array): FlightResponse {
   return parseReactFlightPayload(payload);
 }
 
+/** Decodes the root model from a parsed Flight response. */
 export function decodeFlightResponse(
   response: FlightResponse,
   options: DecodeFlightOptions,
@@ -82,6 +86,7 @@ export function decodeFlightResponse(
   return decodeFlightModel(response.root, response, options) as ReactCompatNode;
 }
 
+/** Reads and parses a Flight response script from a document or parent node. */
 export function readFlightResponse(
   root: Document | ParentNode,
   id?: string,
@@ -99,6 +104,7 @@ export function readFlightResponse(
   return parseFlightResponse(script.textContent);
 }
 
+/** Decodes a Flight response and hydrates the resulting tree into a container. */
 export function hydrateFlightResponse(
   container: Element,
   response: FlightResponse,
@@ -107,6 +113,7 @@ export function hydrateFlightResponse(
   return hydrateRoot(container, decodeFlightResponse(response, options), options.hydrate);
 }
 
+/** Creates a server reference caller that POSTs encoded action invocations to an endpoint. */
 export function createFetchServerReferenceCaller(
   endpoint: string,
   options: FetchServerReferenceCallerOptions = {},

package/src/hooks-entry.ts

@@ -1,3 +1,4 @@
+/** React-compatible hook and transition APIs for the hooks subpath. */
 export {
   useCallback,
   useDebugValue,
@@ -21,4 +22,5 @@ export {
   useTransition,
   version,
 } from "./hooks.js";
+/** Transition function types for the hooks subpath. */
 export type { StartTransition, TransitionScope } from "./hooks.js";