@enjoys/context-engine 1.3.1 → 1.4.2

package/data/hover/protobuf.json

@@ -1,45 +1,290 @@
 {
   "language": "protobuf",
   "hovers": {
+    "syntax": {
+      "contents": [
+        {
+          "value": "```protobuf\nsyntax = \"proto3\";\n```\n**syntax** declares the protobuf version. Use `proto3` for modern projects. `proto2` has required fields and different defaults."
+        }
+      ]
+    },
     "message": {
       "contents": [
         {
-          "value": "```protobuf\nmessage User {\n  string name = 1;\n  int32 age = 2;\n  repeated string tags = 3;\n  map<string, string> metadata = 4;\n  optional string bio = 5;\n}\n```\n**message** defines structured data. Field numbers (1, 2, etc.) are used in binary encoding - never reuse deleted numbers."
+          "value": "```protobuf\nmessage User {\n  string name = 1;\n  int32 age = 2;\n  repeated string tags = 3;\n  map<string, string> metadata = 4;\n  optional string bio = 5;\n}\n```\n**message** defines structured data. Field numbers identify fields in binary encoding — never reuse deleted numbers."
         }
       ]
     },
     "service": {
       "contents": [
         {
-          "value": "```protobuf\nservice UserService {\n  rpc GetUser(GetUserRequest) returns (User);\n  rpc ListUsers(ListUsersRequest) returns (stream User);  // server stream\n  rpc Upload(stream Chunk) returns (UploadResponse);      // client stream\n  rpc Chat(stream Msg) returns (stream Msg);              // bidirectional\n}\n```\n**service** defines gRPC endpoints. Four patterns: unary, server streaming, client streaming, bidirectional."
+          "value": "```protobuf\nservice UserService {\n  rpc GetUser(GetUserRequest) returns (User);\n  rpc ListUsers(ListUsersRequest) returns (stream User);\n  rpc Upload(stream Chunk) returns (UploadResponse);\n  rpc Chat(stream Msg) returns (stream Msg);\n}\n```\n**service** defines gRPC endpoints. Four patterns: unary, server streaming, client streaming, bidirectional."
+        }
+      ]
+    },
+    "rpc": {
+      "contents": [
+        {
+          "value": "```protobuf\nrpc GetUser(GetUserRequest) returns (User);\nrpc ListUsers(Empty) returns (stream User);\n```\n**rpc** defines a remote procedure call within a service. Input and output are message types. `stream` enables streaming."
         }
       ]
     },
     "enum": {
       "contents": [
         {
-          "value": "```protobuf\nenum Status {\n  STATUS_UNSPECIFIED = 0;  // must have 0 value\n  STATUS_ACTIVE = 1;\n  STATUS_INACTIVE = 2;\n}\n```\n**enum** defines named constants. The zero value is required and should be UNSPECIFIED. Use the type name as prefix convention."
+          "value": "```protobuf\nenum Status {\n  STATUS_UNSPECIFIED = 0;\n  STATUS_ACTIVE = 1;\n  STATUS_INACTIVE = 2;\n}\n```\n**enum** defines named constants. Zero value is required and should be UNSPECIFIED. Use type name as prefix."
+        }
+      ]
+    },
+    "oneof": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage SearchResult {\n  oneof result {\n    User user = 1;\n    Group group = 2;\n    string error = 3;\n  }\n}\n```\n**oneof** enforces that at most one field in the group is set. Setting one clears the others. Saves memory."
+        }
+      ]
+    },
+    "repeated": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage User {\n  repeated string tags = 1;\n  repeated Address addresses = 2;\n}\n```\n**repeated** marks a field as a list (zero or more elements). Order is preserved. Can contain scalars or messages."
+        }
+      ]
+    },
+    "map": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Config {\n  map<string, string> properties = 1;\n  map<int32, Feature> features = 2;\n}\n```\n**map** defines key-value pairs. Keys must be integral or string types. Values can be any type except another map."
+        }
+      ]
+    },
+    "optional": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage User {\n  optional string nickname = 1;\n  optional int32 age = 2;\n}\n```\n**optional** (proto3) enables presence tracking. Without it, default values are indistinguishable from unset fields."
+        }
+      ]
+    },
+    "reserved": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Example {\n  reserved 5, 10 to 12;\n  reserved \"old_field\", \"legacy\";\n}\n```\n**reserved** prevents reuse of deleted field numbers or names. Protects against data corruption from old messages."
+        }
+      ]
+    },
+    "import": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/timestamp.proto\";\nimport \"other/messages.proto\";\nimport public \"shared/types.proto\";\n```\n**import** includes definitions from other .proto files. `import public` re-exports the imported definitions."
+        }
+      ]
+    },
+    "package": {
+      "contents": [
+        {
+          "value": "```protobuf\npackage mycompany.myproject.v1;\n```\n**package** namespaces messages to avoid naming conflicts. Maps to language-specific packages (Java package, C++ namespace)."
+        }
+      ]
+    },
+    "option": {
+      "contents": [
+        {
+          "value": "```protobuf\noption java_package = \"com.example.proto\";\noption go_package = \"github.com/user/repo/pb\";\noption java_multiple_files = true;\n```\n**option** configures code generation. Language-specific options control package names, output structure, etc."
         }
       ]
     },
     "field_numbers": {
       "contents": [
         {
-          "value": "```protobuf\nmessage Example {\n  string name = 1;   // 1-15: one byte (use for frequent fields)\n  int32 count = 2;   // 16-2047: two bytes\n  // 19000-19999: reserved by protobuf\n  \n  reserved 5, 10 to 12;          // reserve deleted field numbers\n  reserved \"old_field_name\";     // reserve deleted field names\n}\n```\n**Field numbers** identify fields in the binary format. Use 1-15 for frequently-used fields (more efficient encoding). Never reuse numbers."
+          "value": "```protobuf\nmessage Example {\n  string name = 1;   // 1-15: one byte (frequent fields)\n  int32 count = 16;  // 16-2047: two bytes\n  // 19000-19999: reserved by protobuf\n}\n```\n**Field numbers** identify fields in binary format. Use 1-15 for frequent fields (more efficient). Never reuse numbers."
         }
       ]
     },
     "well_known_types": {
       "contents": [
         {
-          "value": "```protobuf\nimport \"google/protobuf/timestamp.proto\";\nimport \"google/protobuf/duration.proto\";\nimport \"google/protobuf/empty.proto\";\nimport \"google/protobuf/wrappers.proto\";\nimport \"google/protobuf/any.proto\";\nimport \"google/protobuf/struct.proto\";\n```\n**Well-known types** are pre-defined utility messages. Timestamp for dates, Empty for no-data responses, wrappers for nullable scalars."
+          "value": "```protobuf\nimport \"google/protobuf/timestamp.proto\";\nimport \"google/protobuf/duration.proto\";\nimport \"google/protobuf/empty.proto\";\nimport \"google/protobuf/wrappers.proto\";\nimport \"google/protobuf/any.proto\";\nimport \"google/protobuf/struct.proto\";\n```\n**Well-known types** are standard utility messages. Timestamp for dates, Empty for void, wrappers for nullable scalars."
         }
       ]
     },
     "scalar_types": {
       "contents": [
         {
-          "value": "```protobuf\n// Numeric:\ndouble, float           // floating point\nint32, int64            // variable-length signed\nuint32, uint64          // variable-length unsigned\nsint32, sint64          // efficient for negatives\nfixed32, fixed64        // fixed-length unsigned\nsfixed32, sfixed64      // fixed-length signed\n\n// Other:\nbool                    // true/false\nstring                  // UTF-8 text\nbytes                   // raw bytes\n```\n**Scalar types** - choose based on value range and encoding efficiency."
+          "value": "```protobuf\n// Numeric: double, float, int32, int64, uint32, uint64\n//          sint32, sint64 (efficient for negatives)\n//          fixed32, fixed64, sfixed32, sfixed64\n// Other: bool, string, bytes\n```\n**Scalar types** — choose based on value range and encoding efficiency."
+        }
+      ]
+    },
+    "Timestamp": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/timestamp.proto\";\n\nmessage Event {\n  string name = 1;\n  google.protobuf.Timestamp created_at = 2;\n}\n```\n**Timestamp** represents a point in time with seconds and nanoseconds since Unix epoch."
+        }
+      ]
+    },
+    "Duration": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/duration.proto\";\n\nmessage Config {\n  google.protobuf.Duration timeout = 1;\n}\n```\n**Duration** represents a signed length of time with seconds and nanoseconds."
+        }
+      ]
+    },
+    "Any": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/any.proto\";\n\nmessage Response {\n  google.protobuf.Any data = 1;\n}\n```\n**Any** wraps an arbitrary message with a type URL. Use for polymorphic fields when the type isn't known at compile time."
+        }
+      ]
+    },
+    "Empty": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/empty.proto\";\n\nservice MyService {\n  rpc Ping(google.protobuf.Empty) returns (google.protobuf.Empty);\n}\n```\n**Empty** represents a message with no fields. Use for RPCs with no meaningful request/response."
+        }
+      ]
+    },
+    "Struct": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/struct.proto\";\n\nmessage Config {\n  google.protobuf.Struct metadata = 1;  // arbitrary JSON-like data\n}\n```\n**Struct** represents untyped JSON-like data. Use when the schema is dynamic or unknown at compile time."
+        }
+      ]
+    },
+    "FieldMask": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/field_mask.proto\";\n\nmessage UpdateUserRequest {\n  User user = 1;\n  google.protobuf.FieldMask update_mask = 2;\n}\n```\n**FieldMask** specifies which fields to update in a partial update request. Standard pattern for PATCH operations."
+        }
+      ]
+    },
+    "Wrapper": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/wrappers.proto\";\n\nmessage Config {\n  google.protobuf.Int32Value max_retries = 1;\n  google.protobuf.StringValue label = 2;\n}\n```\n**Wrapper types** (Int32Value, StringValue, etc.) provide nullable scalars. Absent wrapper = null, present = has value."
+        }
+      ]
+    },
+    "double": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Point {\n  double latitude = 1;\n  double longitude = 2;\n}\n```\n**double** is a 64-bit IEEE 754 floating point number. Use for precise decimal values."
+        }
+      ]
+    },
+    "float": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Sensor {\n  float temperature = 1;\n}\n```\n**float** is a 32-bit IEEE 754 floating point. Less precise than double but uses less space."
+        }
+      ]
+    },
+    "int32": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Item {\n  int32 quantity = 1;\n}\n```\n**int32** is a variable-length signed 32-bit integer. Inefficient for negative numbers — use `sint32` for those."
+        }
+      ]
+    },
+    "int64": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage File {\n  int64 size_bytes = 1;\n}\n```\n**int64** is a variable-length signed 64-bit integer. Use for large values like file sizes or timestamps."
+        }
+      ]
+    },
+    "uint32": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Config {\n  uint32 port = 1;\n}\n```\n**uint32** is a variable-length unsigned 32-bit integer. Use for values that are always non-negative."
+        }
+      ]
+    },
+    "bool": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Feature {\n  bool enabled = 1;\n}\n```\n**bool** represents true/false. Default value is false in proto3."
+        }
+      ]
+    },
+    "string": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage User {\n  string name = 1;\n  string email = 2;\n}\n```\n**string** must be valid UTF-8 encoded text. Use `bytes` for arbitrary binary data."
+        }
+      ]
+    },
+    "bytes": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage File {\n  bytes content = 1;\n}\n```\n**bytes** holds arbitrary binary data. No UTF-8 requirement. Use for file contents, hashes, etc."
+        }
+      ]
+    },
+    "stream": {
+      "contents": [
+        {
+          "value": "```protobuf\nservice Chat {\n  rpc Send(stream Message) returns (stream Message);\n}\n```\n**stream** enables streaming in RPCs. Can be on request (client streaming), response (server streaming), or both (bidirectional)."
+        }
+      ]
+    },
+    "extend": {
+      "contents": [
+        {
+          "value": "```protobuf\n// Proto2 only:\nextend google.protobuf.MethodOptions {\n  optional string auth_level = 50000;\n}\n```\n**extend** adds custom fields to existing messages (proto2). In proto3, use custom options with extensions."
+        }
+      ]
+    },
+    "deprecated": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage User {\n  string name = 1;\n  string old_email = 2 [deprecated = true];\n  string email = 3;\n}\n```\n**[deprecated = true]** marks a field as deprecated. Generates deprecation warnings in client code."
+        }
+      ]
+    },
+    "json_name": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage User {\n  string user_name = 1 [json_name = \"userName\"];\n}\n```\n**[json_name]** overrides the JSON field name. By default, proto field names use camelCase in JSON."
+        }
+      ]
+    },
+    "default_values": {
+      "contents": [
+        {
+          "value": "```protobuf\n// Proto3 default values:\n// string: \"\"    int32: 0    bool: false\n// enum: first value (0)\n// message: null  repeated: empty list\n// bytes: empty bytes\n```\n**Default values** in proto3 are always zero/empty. There's no way to distinguish \"not set\" from default without `optional`."
+        }
+      ]
+    },
+    "nested_message": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Order {\n  message LineItem {\n    string product = 1;\n    int32 quantity = 2;\n  }\n  repeated LineItem items = 1;\n}\n```\n**Nested messages** are defined inside another message. Referenced as `Order.LineItem` from outside."
+        }
+      ]
+    },
+    "encoding": {
+      "contents": [
+        {
+          "value": "```protobuf\n// Wire types:\n// 0: Varint (int32, int64, uint32, uint64, sint32, sint64, bool, enum)\n// 1: 64-bit (fixed64, sfixed64, double)\n// 2: Length-delimited (string, bytes, messages, repeated)\n// 5: 32-bit (fixed32, sfixed32, float)\n```\n**Wire format** uses 5 wire types for binary encoding. Varint encoding makes small numbers compact."
+        }
+      ]
+    },
+    "sint32": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Delta {\n  sint32 offset = 1;\n}\n```\n**sint32** uses ZigZag encoding, making negative values much more compact than `int32`. Use when values are frequently negative."
+        }
+      ]
+    },
+    "fixed64": {
+      "contents": [
+        {
+          "value": "```protobuf\nmessage Hash {\n  fixed64 value = 1;\n}\n```\n**fixed64** is always 8 bytes. More efficient than `int64` when values are frequently > 2^56."
+        }
+      ]
+    },
+    "option_custom": {
+      "contents": [
+        {
+          "value": "```protobuf\nimport \"google/protobuf/descriptor.proto\";\n\nextend google.protobuf.FieldOptions {\n  optional bool sensitive = 50000;\n}\n\nmessage User {\n  string password = 1 [(sensitive) = true];\n}\n```\n**Custom options** extend built-in options for fields, messages, services, etc. Use high field numbers (50000+)."
         }
       ]
     }

package/data/hover/react.json

@@ -0,0 +1,173 @@
+{
+  "language": "react",
+  "hovers": {
+    "useState": {
+      "contents": [{ "value": "```jsx\nfunction useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>]\n```\nReturns a stateful value and a function to update it. During the initial render, the returned state matches the passed `initialState`. The `setState` function is used to update the state, triggering a re-render of the component." }]
+    },
+    "useEffect": {
+      "contents": [{ "value": "```jsx\nfunction useEffect(effect: EffectCallback, deps?: DependencyList): void\n```\nAccepts a function that contains imperative, possibly effectful code. Mutations, subscriptions, timers, logging, and other side effects are performed here. The function runs after every completed render by default. Provide a dependency array to control when the effect runs." }]
+    },
+    "useContext": {
+      "contents": [{ "value": "```jsx\nfunction useContext<T>(context: Context<T>): T\n```\nAccepts a context object (from `React.createContext`) and returns the current context value for that context. The value is determined by the `value` prop of the nearest `<MyContext.Provider>` above the calling component." }]
+    },
+    "useReducer": {
+      "contents": [{ "value": "```jsx\nfunction useReducer<R extends Reducer<any, any>>(reducer: R, initialState: ReducerState<R>): [ReducerState<R>, Dispatch<ReducerAction<R>>]\n```\nAn alternative to `useState` for managing complex state logic. Accepts a reducer of type `(state, action) => newState` and returns the current state paired with a `dispatch` method. Preferred when state logic involves multiple sub-values." }]
+    },
+    "useMemo": {
+      "contents": [{ "value": "```jsx\nfunction useMemo<T>(factory: () => T, deps: DependencyList): T\n```\nReturns a memoized value. Only recomputes when one of the dependencies has changed. This optimization helps avoid expensive calculations on every render. The function is called during rendering, so keep it pure." }]
+    },
+    "useCallback": {
+      "contents": [{ "value": "```jsx\nfunction useCallback<T extends Function>(callback: T, deps: DependencyList): T\n```\nReturns a memoized callback function. The callback only changes when one of the dependencies changes. Useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders." }]
+    },
+    "useRef": {
+      "contents": [{ "value": "```jsx\nfunction useRef<T>(initialValue: T): MutableRefObject<T>\n```\nReturns a mutable ref object whose `.current` property is initialized to the passed argument. The returned object persists for the full lifetime of the component. Commonly used for DOM access and storing mutable values without triggering re-renders." }]
+    },
+    "useLayoutEffect": {
+      "contents": [{ "value": "```jsx\nfunction useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void\n```\nIdentical to `useEffect`, but fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates inside `useLayoutEffect` will be flushed before the browser paints." }]
+    },
+    "useId": {
+      "contents": [{ "value": "```jsx\nfunction useId(): string\n```\nGenerates unique IDs that are stable across server and client. Avoids hydration mismatches. Primarily used for accessibility attributes like `htmlFor` and `aria-describedby`." }]
+    },
+    "useTransition": {
+      "contents": [{ "value": "```jsx\nfunction useTransition(): [boolean, (callback: () => void) => void]\n```\nReturns `[isPending, startTransition]`. Lets you mark state updates as transitions, so they can be interrupted by more urgent updates. `isPending` indicates when a transition is waiting." }]
+    },
+    "useDeferredValue": {
+      "contents": [{ "value": "```jsx\nfunction useDeferredValue<T>(value: T): T\n```\nAccepts a value and returns a deferred version that may lag behind. Useful for keeping the interface responsive when triggering expensive re-renders (e.g., filtering a large list)." }]
+    },
+    "useSyncExternalStore": {
+      "contents": [{ "value": "```jsx\nfunction useSyncExternalStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T\n```\nSubscribes to an external store. Recommended for integrating non-React state management (Redux, Zustand, etc.) with React. Ensures consistent reads during concurrent rendering." }]
+    },
+    "useImperativeHandle": {
+      "contents": [{ "value": "```jsx\nfunction useImperativeHandle<T>(ref: Ref<T>, createHandle: () => T, deps?: DependencyList): void\n```\nCustomizes the instance value that is exposed to parent components when using `ref`. Should be used with `forwardRef`. Controls which methods or values parents can access." }]
+    },
+    "useDebugValue": {
+      "contents": [{ "value": "```jsx\nfunction useDebugValue<T>(value: T, format?: (value: T) => any): void\n```\nDisplays a label for custom hooks in React DevTools. Optionally accepts a formatting function to defer expensive formatting until the hook is inspected." }]
+    },
+    "useInsertionEffect": {
+      "contents": [{ "value": "```jsx\nfunction useInsertionEffect(effect: EffectCallback, deps?: DependencyList): void\n```\nFires synchronously before all DOM mutations. Designed for CSS-in-JS libraries to inject `<style>` rules before any layout effects read from the DOM." }]
+    },
+    "useOptimistic": {
+      "contents": [{ "value": "```jsx\nfunction useOptimistic<T, A>(passthrough: T, reducer: (state: T, action: A) => T): [T, (action: A) => void]\n```\nAllows optimistic UI updates while an async action is underway. Shows the optimistic state immediately, then reverts or updates when the async operation completes." }]
+    },
+    "useFormStatus": {
+      "contents": [{ "value": "```jsx\nfunction useFormStatus(): { pending: boolean; data: FormData | null; method: string | null; action: string | null }\n```\nGives status information of the last form submission. Must be called from a component rendered inside a `<form>`. Useful for disabling submit buttons during pending submissions." }]
+    },
+    "useActionState": {
+      "contents": [{ "value": "```jsx\nfunction useActionState<T>(action: (state: T, payload: FormData) => T | Promise<T>, initialState: T, permalink?: string): [T, (payload: FormData) => void]\n```\nUpdates state based on the result of a form action. Returns the current state and a wrapped action function. The action can be async and the state updates once it resolves." }]
+    },
+    "use": {
+      "contents": [{ "value": "```jsx\nfunction use<T>(resource: Promise<T> | Context<T>): T\n```\nReads the value of a resource like a Promise or context. Unlike other hooks, `use` can be called conditionally and inside loops. When called with a Promise, it integrates with Suspense and Error Boundaries." }]
+    },
+    "createElement": {
+      "contents": [{ "value": "```jsx\nfunction createElement(type: string | ComponentType, props?: object | null, ...children: ReactNode[]): ReactElement\n```\nCreates and returns a new React element of the given type. The type can be a tag name string (`'div'`), a React component type (class or function), or a React Fragment. JSX compiles to `createElement` calls." }]
+    },
+    "cloneElement": {
+      "contents": [{ "value": "```jsx\nfunction cloneElement(element: ReactElement, props?: object, ...children: ReactNode[]): ReactElement\n```\nClone and return a new React element using `element` as the starting point. New props are shallowly merged with the original. New children replace existing children." }]
+    },
+    "createContext": {
+      "contents": [{ "value": "```jsx\nfunction createContext<T>(defaultValue: T): Context<T>\n```\nCreates a Context object. When React renders a component that subscribes to this Context, it reads the current value from the closest matching `Provider` above it in the tree. The `defaultValue` is used when there is no matching Provider." }]
+    },
+    "forwardRef": {
+      "contents": [{ "value": "```jsx\nfunction forwardRef<T, P>(render: (props: P, ref: Ref<T>) => ReactElement | null): ForwardRefExoticComponent<P & RefAttributes<T>>\n```\nCreates a React component that forwards the `ref` attribute to a child component. Allows parent components to access a child's DOM element or component instance." }]
+    },
+    "lazy": {
+      "contents": [{ "value": "```jsx\nfunction lazy<T extends ComponentType<any>>(factory: () => Promise<{ default: T }>): LazyExoticComponent<T>\n```\nDefines a component that is loaded dynamically. Takes a function that returns a `Promise` resolving to a module with a `default` export containing a React component. Must be wrapped in `<Suspense>`." }]
+    },
+    "memo": {
+      "contents": [{ "value": "```jsx\nfunction memo<P>(Component: FunctionComponent<P>, propsAreEqual?: (prev: P, next: P) => boolean): NamedExoticComponent<P>\n```\nHigher-order component that memoizes results. If props are the same, React skips rendering the component and reuses the last result. Optionally accepts a custom comparison function." }]
+    },
+    "startTransition": {
+      "contents": [{ "value": "```jsx\nfunction startTransition(scope: () => void): void\n```\nMarks state updates inside the provided callback as transitions. Transitions are non-urgent and can be interrupted by more pressing updates (like typing), keeping the UI responsive." }]
+    },
+    "createPortal": {
+      "contents": [{ "value": "```jsx\nfunction createPortal(children: ReactNode, container: Element | DocumentFragment, key?: string): ReactPortal\n```\nCreates a portal that renders `children` into a DOM node (`container`) outside the parent component's DOM hierarchy. Events still bubble through the React tree, not the DOM tree." }]
+    },
+    "createRoot": {
+      "contents": [{ "value": "```jsx\nfunction createRoot(container: Element | DocumentFragment, options?: RootOptions): Root\n```\nCreates a React root for displaying content inside a browser DOM node. The React 18+ entry point. Call `root.render(<App />)` to display your application." }]
+    },
+    "hydrateRoot": {
+      "contents": [{ "value": "```jsx\nfunction hydrateRoot(container: Element | Document, initialChildren: ReactNode, options?: HydrateRootOptions): Root\n```\nHydrates a server-rendered container. React attaches event listeners and takes over management of the HTML generated by `react-dom/server`, making it interactive." }]
+    },
+    "flushSync": {
+      "contents": [{ "value": "```jsx\nfunction flushSync<R>(fn: () => R): R\n```\nForces React to flush any state updates inside the provided callback synchronously. The DOM is updated immediately. Use sparingly — `flushSync` can significantly hurt performance." }]
+    },
+    "Fragment": {
+      "contents": [{ "value": "```jsx\n<Fragment>children</Fragment>\n// or shorthand:\n<>children</>\n```\nLets you group elements without a wrapper DOM node. The short syntax `<>...</>` is equivalent to `<Fragment>...</Fragment>` but doesn't support the `key` prop." }]
+    },
+    "StrictMode": {
+      "contents": [{ "value": "```jsx\n<StrictMode>children</StrictMode>\n```\nActivates additional development-only checks for the component tree. Components re-render twice, effects run twice, and deprecated APIs trigger warnings. Helps find common bugs early." }]
+    },
+    "Suspense": {
+      "contents": [{ "value": "```jsx\n<Suspense fallback={<Loading />}>children</Suspense>\n```\nDisplays the `fallback` while its children are loading (lazy components, data fetching with Suspense-enabled frameworks). When loading completes, the `fallback` is replaced with the actual content." }]
+    },
+    "Profiler": {
+      "contents": [{ "value": "```jsx\n<Profiler id=\"name\" onRender={callback}>children</Profiler>\n```\nMeasures rendering performance of a React tree. The `onRender` callback receives `(id, phase, actualDuration, baseDuration, startTime, commitTime)` for each commit." }]
+    },
+    "Component": {
+      "contents": [{ "value": "```jsx\nclass MyComponent extends React.Component<Props, State> {\n  render() { return <div />; }\n}\n```\nBase class for React class components. Provides lifecycle methods, `this.state`, `this.props`, and `this.setState()`. Function components with hooks are now the recommended approach." }]
+    },
+    "PureComponent": {
+      "contents": [{ "value": "```jsx\nclass MyComponent extends React.PureComponent<Props, State> {\n  render() { return <div />; }\n}\n```\nSimilar to `Component` but implements `shouldComponentUpdate()` with a shallow prop and state comparison. Skips re-renders when props and state are shallowly equal." }]
+    },
+    "Children": {
+      "contents": [{ "value": "```jsx\nReact.Children.map(children, fn)\nReact.Children.forEach(children, fn)\nReact.Children.count(children)\nReact.Children.only(children)\nReact.Children.toArray(children)\n```\nUtilities for working with the opaque `children` data structure. Provides safe iteration and transformation methods that handle all children types (single elements, arrays, fragments)." }]
+    },
+    "Children.map": {
+      "contents": [{ "value": "```jsx\nReact.Children.map(children: ReactNode, fn: (child: ReactNode, index: number) => ReactNode): ReactNode[]\n```\nInvokes a function on every immediate child contained within `children`. Returns a flat array with keys assigned. Returns `null` or `undefined` if children is `null` or `undefined`." }]
+    },
+    "Children.forEach": {
+      "contents": [{ "value": "```jsx\nReact.Children.forEach(children: ReactNode, fn: (child: ReactNode, index: number) => void): void\n```\nLike `React.Children.map()` but does not return an array. Iterates over children for side effects only." }]
+    },
+    "Children.count": {
+      "contents": [{ "value": "```jsx\nReact.Children.count(children: ReactNode): number\n```\nReturns the total number of components in `children`, equal to the number of times a callback passed to `map` or `forEach` would be invoked." }]
+    },
+    "Children.only": {
+      "contents": [{ "value": "```jsx\nReact.Children.only(children: ReactNode): ReactElement\n```\nVerifies that `children` has only one child (a React element) and returns it. Throws an error if children has multiple children or is not a React element." }]
+    },
+    "Children.toArray": {
+      "contents": [{ "value": "```jsx\nReact.Children.toArray(children: ReactNode): ReactNode[]\n```\nReturns the `children` opaque data structure as a flat array with keys assigned to each child. Useful for manipulating children before passing them down." }]
+    },
+    "isValidElement": {
+      "contents": [{ "value": "```jsx\nfunction isValidElement(object: any): object is ReactElement\n```\nVerifies the object is a React element (created by `createElement`, JSX, or `cloneElement`). Returns `true` for React elements, `false` for everything else." }]
+    },
+    "cache": {
+      "contents": [{ "value": "```jsx\nfunction cache<T extends Function>(fn: T): T\n```\nWraps a function to cache its result. When the cached function is called with the same arguments, it returns the previous result without re-executing. Primarily used with React Server Components." }]
+    },
+    "experimental_taintObjectReference": {
+      "contents": [{ "value": "```jsx\nfunction experimental_taintObjectReference(message: string, object: object): void\n```\nPrevents a specific object instance from being passed to a Client Component. If someone tries, React throws an error with the provided `message`. A security feature for Server Components." }]
+    },
+    "renderToString": {
+      "contents": [{ "value": "```jsx\nfunction renderToString(element: ReactElement): string\n```\nRenders a React tree to an HTML string. Does not support Suspense streaming. On the client, call `hydrateRoot` to make the HTML interactive. Prefer `renderToPipeableStream` for streaming SSR." }]
+    },
+    "renderToStaticMarkup": {
+      "contents": [{ "value": "```jsx\nfunction renderToStaticMarkup(element: ReactElement): string\n```\nRenders a non-interactive React tree to an HTML string. The output has no React-specific attributes and cannot be hydrated. Use for generating static HTML like emails." }]
+    },
+    "renderToPipeableStream": {
+      "contents": [{ "value": "```jsx\nfunction renderToPipeableStream(element: ReactNode, options?: RenderToPipeableStreamOptions): PipeableStream\n```\nRenders a React tree to a pipeable Node.js Stream with full Suspense support. Returns `{ pipe, abort }`. This is the recommended SSR API for Node.js." }]
+    },
+    "renderToReadableStream": {
+      "contents": [{ "value": "```jsx\nfunction renderToReadableStream(element: ReactNode, options?: RenderToReadableStreamOptions): Promise<ReadableStream>\n```\nRenders a React tree to a Web Readable Stream. Returns a Promise that resolves to a ReadableStream. For edge runtimes and Deno." }]
+    },
+    "preload": {
+      "contents": [{ "value": "```jsx\nfunction preload(href: string, options: { as: string }): void\n```\nEagerly fetches a resource (stylesheet, font, script). Call from a component to start loading a resource before it's actually needed." }]
+    },
+    "prefetchDNS": {
+      "contents": [{ "value": "```jsx\nfunction prefetchDNS(href: string): void\n```\nEagerly looks up the IP of a server that you expect to load resources from. Reduces latency for future requests." }]
+    },
+    "preconnect": {
+      "contents": [{ "value": "```jsx\nfunction preconnect(href: string, options?: { crossOrigin?: string }): void\n```\nEagerly connects to a server (DNS + TCP + TLS). Reduces latency for future resource loads from that server." }]
+    },
+    "preinit": {
+      "contents": [{ "value": "```jsx\nfunction preinit(href: string, options: { as: 'style' | 'script' }): void\n```\nEagerly fetches and evaluates a stylesheet or external script. The resource is loaded and executed immediately." }]
+    },
+    "act": {
+      "contents": [{ "value": "```jsx\nawait act(async () => { /* trigger updates */ });\n```\nWraps code that causes React state updates. Ensures all updates, effects, and state changes are processed before assertions. Essential for reliable React testing." }]
+    },
+    "unmountComponentAtNode": {
+      "contents": [{ "value": "```jsx\nfunction unmountComponentAtNode(container: Element): boolean\n```\n**Legacy API**. Removes a mounted React component from the DOM. Use `root.unmount()` with `createRoot` instead. Returns `true` if a component was unmounted." }]
+    },
+    "findDOMNode": {
+      "contents": [{ "value": "```jsx\nfunction findDOMNode(instance: Component): Element | null\n```\n**Legacy API**. Finds the browser DOM node for a class component instance. Use refs instead. Not supported in StrictMode." }]
+    }
+  }
+}