Merge branch 'main' into pr34995

[compiler] Fix false negatives and add data flow tree to compiler error for no-deriving-state-in-effects
Summary: Revamped the derivationCache graph. This fixes a bunch of bugs where sometimes we fail to track from which props/state we derived values from. Also, it is more intuitive and allows us to easily implement a Data Flow Tree. We can print this tree which gives insight on how the data is derived and should facilitate error resolution in complicated components Test Plan: Added a test case where we were failing to track derivations. Also updated the test cases with the new error containing the data flow tree
2025-11-10 12:09:00 -08:00 · 2025-11-04 10:33:13 -08:00 · 2025-10-28 15:58:14 -07:00
682 changed files with 5393 additions and 16939 deletions
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -331,7 +331,6 @@ module.exports = {
        'packages/react-server-dom-turbopack/**/*.js',
        'packages/react-server-dom-parcel/**/*.js',
        'packages/react-server-dom-fb/**/*.js',
-        'packages/react-server-dom-unbundled/**/*.js',
        'packages/react-test-renderer/**/*.js',
        'packages/react-debug-tools/**/*.js',
        'packages/react-devtools-extensions/**/*.js',
@@ -635,7 +634,6 @@ module.exports = {
    FocusOptions: 'readonly',
    OptionalEffectTiming: 'readonly',

-    __REACT_ROOT_PATH_TEST__: 'readonly',
    spyOnDev: 'readonly',
    spyOnDevAndProd: 'readonly',
    spyOnProd: 'readonly',
--- a/.github/workflows/runtime_build_and_test.yml
+++ b/.github/workflows/runtime_build_and_test.yml
@@ -3,10 +3,6 @@ name: (Runtime) Build and Test
 on:
  push:
    branches: [main]
-    tags:
-      # To get CI for backport releases.
-      # This will duplicate CI for releases from main which is acceptable
-      - "v*"
  pull_request:
    paths-ignore:
      - compiler/**
@@ -45,7 +41,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
          lookup-only: true
      - uses: actions/setup-node@v4
        if: steps.node_modules.outputs.cache-hit != 'true'
@@ -59,8 +55,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - run: yarn install --frozen-lockfile
        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Save cache
@@ -69,7 +67,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}

  runtime_compiler_node_modules_cache:
    name: Cache Runtime, Compiler node_modules
@@ -84,7 +82,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
          lookup-only: true
      - uses: actions/setup-node@v4
        if: steps.node_modules.outputs.cache-hit != 'true'
@@ -100,8 +98,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          restore-keys: |
+            runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-and-compiler-node_modules-v6-
      - run: yarn install --frozen-lockfile
        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn --cwd compiler install --frozen-lockfile
@@ -112,7 +112,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}

  # ----- FLOW -----
  discover_flow_inline_configs:
@@ -154,8 +154,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -182,8 +184,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -212,7 +216,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -270,8 +274,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          restore-keys: |
+            runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-and-compiler-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -300,7 +306,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
      - name: Install runtime dependencies
        run: yarn install --frozen-lockfile
        if: steps.node_modules.outputs.cache-hit != 'true'
@@ -343,8 +349,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          restore-keys: |
+            runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-and-compiler-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -382,6 +390,9 @@ jobs:
          -r=experimental --env=development,
          -r=experimental --env=production,

+          # Dev Tools
+          --project=devtools -r=experimental,
+
          # TODO: Update test config to support www build tests
          # - "-r=www-classic --env=development --variant=false"
          # - "-r=www-classic --env=production --variant=false"
@@ -429,8 +440,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
+          restore-keys: |
+            runtime-and-compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-and-compiler-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -447,50 +460,6 @@ jobs:
        run: ls -R build
      - run: yarn test --build ${{ matrix.test_params }} --shard=${{ matrix.shard }} --ci

-  test_build_devtools:
-    name: yarn test-build (devtools)
-    needs: [build_and_lint, runtime_node_modules_cache]
-    strategy:
-      fail-fast: false
-      matrix:
-        shard:
-          - 1/5
-          - 2/5
-          - 3/5
-          - 4/5
-          - 5/5
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.inputs.commit_sha != '' && github.event.inputs.commit_sha || github.event.pull_request.head.sha || github.sha }}
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          cache: yarn
-          cache-dependency-path: yarn.lock
-      - name: Restore cached node_modules
-        uses: actions/cache/restore@v4
-        id: node_modules
-        with:
-          path: |
-            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
-      - name: Ensure clean build directory
-        run: rm -rf build
-      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Restore archived build
-        uses: actions/download-artifact@v4
-        with:
-          pattern: _build_*
-          path: build
-          merge-multiple: true
-      - name: Display structure of build
-        run: ls -R build
-      - run: yarn test --build --project=devtools -r=experimental --shard=${{ matrix.shard }} --ci
-
  process_artifacts_combined:
    name: Process artifacts combined
    needs: [build_and_lint, runtime_node_modules_cache]
@@ -514,8 +483,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -577,8 +548,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -615,8 +588,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -765,8 +740,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
@@ -825,8 +802,10 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-node_modules-v7-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
-          # Don't use restore-keys here. Otherwise the cache grows indefinitely.
+          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+          restore-keys: |
+            runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-
+            runtime-node_modules-v6-
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,3 @@
-## 19.2.1 (Dec 3, 2025)
-
-### React Server Components
-
- Bring React Server Component fixes to Server Actions (@sebmarkbage [#35277](https://github.com/facebook/react/pull/35277))
-
 ## 19.2.0 (October 1st, 2025)

 Below is a list of all new features, APIs, and bug fixes.
@@ -77,12 +71,6 @@ Read the [React 19.2 release post](https://react.dev/blog/2025/10/01/react-19-2)

 - [createContainer](https://github.com/facebook/react/blob/v19.2.0/packages/react-reconciler/src/ReactFiberReconciler.js#L255-L261) and [createHydrationContainer](https://github.com/facebook/react/blob/v19.2.0/packages/react-reconciler/src/ReactFiberReconciler.js#L305-L312) had their parameter order adjusted after `on*` handlers to account for upcoming experimental APIs

-## 19.1.2 (Dec 3, 2025)
-
-### React Server Components
-
- Bring React Server Component fixes to Server Actions (@sebmarkbage [#35277](https://github.com/facebook/react/pull/35277))
-
 ## 19.1.1 (July 28, 2025)

 ### React
@@ -135,12 +123,6 @@ An Owner Stack is a string representing the components that are directly respons
 * Exposed `registerServerReference` in client builds to handle server references in different environments. [#32534](https://github.com/facebook/react/pull/32534)
 * Added react-server-dom-parcel package which integrates Server Components with the [Parcel bundler](https://parceljs.org/) [#31725](https://github.com/facebook/react/pull/31725), [#32132](https://github.com/facebook/react/pull/32132), [#31799](https://github.com/facebook/react/pull/31799), [#32294](https://github.com/facebook/react/pull/32294), [#31741](https://github.com/facebook/react/pull/31741)

-## 19.0.1 (Dec 3, 2025)
-
-### React Server Components
-
- Bring React Server Component fixes to Server Actions (@sebmarkbage [#35277](https://github.com/facebook/react/pull/35277))
-
 ## 19.0.0 (December 5, 2024)

 Below is a list of all new features, APIs, deprecations, and breaking changes. Read [React 19 release post](https://react.dev/blog/2024/04/25/react-19) and [React 19 upgrade guide](https://react.dev/blog/2024/04/25/react-19-upgrade-guide) for more information.
--- a/compiler/.claude/settings.json
+++ b/compiler/.claude/settings.json
@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(yarn snap:*)",
-      "Bash(yarn snap:build)",
-      "Bash(node scripts/enable-feature-flag.js:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}
--- a/compiler/.gitignore
+++ b/compiler/.gitignore
@@ -8,9 +8,7 @@ dist
 .vscode
 !packages/playground/.vscode
 testfilter.txt
-.claude/settings.local.json

 # forgive
 *.vsix
 .vscode-test
-
--- a/compiler/CLAUDE.md
+++ b/compiler/CLAUDE.md
@@ -1,221 +0,0 @@
-# React Compiler Knowledge Base
-
-This document contains knowledge about the React Compiler gathered during development sessions. It serves as a reference for understanding the codebase architecture and key concepts.
-
-## Project Structure
-
- `packages/babel-plugin-react-compiler/` - Main compiler package
-  - `src/HIR/` - High-level Intermediate Representation types and utilities
-  - `src/Inference/` - Effect inference passes (aliasing, mutation, etc.)
-  - `src/Validation/` - Validation passes that check for errors
-  - `src/Entrypoint/Pipeline.ts` - Main compilation pipeline with pass ordering
-  - `src/__tests__/fixtures/compiler/` - Test fixtures
-    - `error.todo-*.js` - Unsupported feature, correctly throws Todo error (graceful bailout)
-    - `error.bug-*.js` - Known bug, throws wrong error type or incorrect behavior
-    - `*.expect.md` - Expected output for each fixture
-
-## Running Tests
-
-```bash
-# Run all tests
-yarn snap
-
-# Run tests matching a pattern
-# Example: yarn snap -p 'error.*'
-yarn snap -p <pattern>
-
-# Run a single fixture in debug mode. Use the path relative to the __tests__/fixtures/compiler directory
-# For each step of compilation, outputs the step name and state of the compiled program
-# Example: yarn snap -p simple.js -d
-yarn snap -p <file-basename> -d
-
-# Update fixture outputs (also works with -p)
-yarn snap -u
-```
-
-## Version Control
-
-This repository uses Sapling (`sl`) for version control. Sapling is similar to Mercurial: there is not staging area, but new/deleted files must be explicitlyu added/removed.
-
-```bash
-# Check status
-sl status
-
-# Add new files, remove deleted files
-sl addremove
-
-# Commit all changes
-sl commit -m "Your commit message"
-
-# Commit with multi-line message using heredoc
-sl commit -m "$(cat <<'EOF'
-Summary line
-
-Detailed description here
-EOF
-)"
-```
-
-## Key Concepts
-
-### HIR (High-level Intermediate Representation)
-
-The compiler converts source code to HIR for analysis. Key types in `src/HIR/HIR.ts`:
-
- **HIRFunction** - A function being compiled
-  - `body.blocks` - Map of BasicBlocks
-  - `context` - Captured variables from outer scope
-  - `params` - Function parameters
-  - `returns` - The function's return place
-  - `aliasingEffects` - Effects that describe the function's behavior when called
-
- **Instruction** - A single operation
-  - `lvalue` - The place being assigned to
-  - `value` - The instruction kind (CallExpression, FunctionExpression, LoadLocal, etc.)
-  - `effects` - Array of AliasingEffects for this instruction
-
- **Terminal** - Block terminators (return, branch, etc.)
-  - `effects` - Array of AliasingEffects
-
- **Place** - A reference to a value
-  - `identifier.id` - Unique IdentifierId
-
- **Phi nodes** - Join points for values from different control flow paths
-  - Located at `block.phis`
-  - `phi.place` - The result place
-  - `phi.operands` - Map of predecessor block to source place
-
-### AliasingEffects System
-
-Effects describe data flow and operations. Defined in `src/Inference/AliasingEffects.ts`:
-
-**Data Flow Effects:**
- `Impure` - Marks a place as containing an impure value (e.g., Date.now() result, ref.current)
- `Capture a -> b` - Value from `a` is captured into `b` (mutable capture)
- `Alias a -> b` - `b` aliases `a`
- `ImmutableCapture a -> b` - Immutable capture (like Capture but read-only)
- `Assign a -> b` - Direct assignment
- `MaybeAlias a -> b` - Possible aliasing
- `CreateFrom a -> b` - Created from source
-
-**Mutation Effects:**
- `Mutate value` - Value is mutated
- `MutateTransitive value` - Value and transitive captures are mutated
- `MutateConditionally value` - May mutate
- `MutateTransitiveConditionally value` - May mutate transitively
-
-**Other Effects:**
- `Render place` - Place is used in render context (JSX props, component return)
- `Freeze place` - Place is frozen (made immutable)
- `Create place` - New value created
- `CreateFunction` - Function expression created, includes `captures` array
- `Apply` - Function application with receiver, function, args, and result
-
-### Hook Aliasing Signatures
-
-Located in `src/HIR/Globals.ts`, hooks can define custom aliasing signatures to control how data flows through them.
-
-**Structure:**
-```typescript
-aliasing: {
-  receiver: '@receiver',    // The hook function itself
-  params: ['@param0'],      // Named positional parameters
-  rest: '@rest',            // Rest parameters (or null)
-  returns: '@returns',      // Return value
-  temporaries: [],          // Temporary values during execution
-  effects: [                // Array of effects to apply when hook is called
-    {kind: 'Freeze', value: '@param0', reason: ValueReason.HookCaptured},
-    {kind: 'Assign', from: '@param0', into: '@returns'},
-  ],
-}
-```
-
-**Common patterns:**
-
-1. **RenderHookAliasing** (useState, useContext, useMemo, useCallback):
-   - Freezes arguments (`Freeze @rest`)
-   - Marks arguments as render-time (`Render @rest`)
-   - Creates frozen return value
-   - Aliases arguments to return
-
-2. **EffectHookAliasing** (useEffect, useLayoutEffect, useInsertionEffect):
-   - Freezes function and deps
-   - Creates internal effect object
-   - Captures function and deps into effect
-   - Returns undefined
-
-3. **Event handler hooks** (useEffectEvent):
-   - Freezes callback (`Freeze @fn`)
-   - Aliases input to return (`Assign @fn -> @returns`)
-   - NO Render effect (callback not called during render)
-
-**Example: useEffectEvent**
-```typescript
-const UseEffectEventHook = addHook(
-  DEFAULT_SHAPES,
-  {
-    positionalParams: [Effect.Freeze],  // Takes one positional param
-    restParam: null,
-    returnType: {kind: 'Function', ...},
-    calleeEffect: Effect.Read,
-    hookKind: 'useEffectEvent',
-    returnValueKind: ValueKind.Frozen,
-    aliasing: {
-      receiver: '@receiver',
-      params: ['@fn'],              // Name for the callback parameter
-      rest: null,
-      returns: '@returns',
-      temporaries: [],
-      effects: [
-        {kind: 'Freeze', value: '@fn', reason: ValueReason.HookCaptured},
-        {kind: 'Assign', from: '@fn', into: '@returns'},
-        // Note: NO Render effect - callback is not called during render
-      ],
-    },
-  },
-  BuiltInUseEffectEventId,
-);
-
-// Add as both names for compatibility
-['useEffectEvent', UseEffectEventHook],
-['experimental_useEffectEvent', UseEffectEventHook],
-```
-
-**Key insight:** If a hook is missing an `aliasing` config, it falls back to `DefaultNonmutatingHook` which includes a `Render` effect on all arguments. This can cause false positives for hooks like `useEffectEvent` whose callbacks are not called during render.
-
-## Feature Flags
-
-Feature flags are configured in `src/HIR/Environment.ts`, for example `enableJsxOutlining`. Test fixtures can override the active feature flags used for that fixture via a comment pragma on the first line of the fixture input, for example:
-
-```javascript
-// enableJsxOutlining @enableChangeVariableCodegen:false
-
-...code...
-```
-
-Would enable the `enableJsxOutlining` feature and disable the `enableChangeVariableCodegen` feature.
-
-## Debugging Tips
-
-1. Run `yarn snap -p <fixture>` to see full HIR output with effects
-2. Look for `@aliasingEffects=` on FunctionExpressions
-3. Look for `Impure`, `Render`, `Capture` effects on instructions
-4. Check the pass ordering in Pipeline.ts to understand when effects are populated vs validated
-
-## Error Handling for Unsupported Features
-
-When the compiler encounters an unsupported but known pattern, use `CompilerError.throwTodo()` instead of `CompilerError.invariant()`. Todo errors cause graceful bailouts in production; Invariant errors are hard failures indicating unexpected/invalid states.
-
-```typescript
-// Unsupported but expected pattern - graceful bailout
-CompilerError.throwTodo({
-  reason: `Support [description of unsupported feature]`,
-  loc: terminal.loc,
-});
-
-// Invariant is for truly unexpected/invalid states - hard failure
-CompilerError.invariant(false, {
-  reason: `Unexpected [thing]`,
-  loc: terminal.loc,
-});
-```
--- a/compiler/apps/playground/.gitignore
+++ b/compiler/apps/playground/.gitignore
@@ -12,7 +12,6 @@
 # next.js
 /.next/
 /out/
-/next-env.d.ts

 # production
 /build
--- a/compiler/apps/playground/components/Editor/ConfigEditor.tsx
+++ b/compiler/apps/playground/components/Editor/ConfigEditor.tsx
@@ -14,6 +14,7 @@ import React, {
  unstable_ViewTransition as ViewTransition,
  unstable_addTransitionType as addTransitionType,
  startTransition,
+  Activity,
 } from 'react';
 import {Resizable} from 're-resizable';
 import {useStore, useStoreDispatch} from '../StoreContext';
@@ -33,14 +34,9 @@ export default function ConfigEditor({
 }): React.ReactElement {
  const [isExpanded, setIsExpanded] = useState(false);

-  // TODO: Add back <Activity> after upgrading next.js
  return (
    <>
-      <div
-        style={{
-          display: isExpanded ? 'block' : 'none',
-        }}>
-        {/* <Activity mode={isExpanded ? 'visible' : 'hidden'}> */}
+      <Activity mode={isExpanded ? 'visible' : 'hidden'}>
        <ExpandedEditor
          onToggle={() => {
            startTransition(() => {
@@ -50,13 +46,8 @@ export default function ConfigEditor({
          }}
          formattedAppliedConfig={formattedAppliedConfig}
        />
-      </div>
-      <div
-        style={{
-          display: !isExpanded ? 'block' : 'none',
-        }}>
-        {/* </Activity>
-        <Activity mode={isExpanded ? 'hidden' : 'visible'}></Activity> */}
+      </Activity>
+      <Activity mode={isExpanded ? 'hidden' : 'visible'}>
        <CollapsedEditor
          onToggle={() => {
            startTransition(() => {
@@ -65,8 +56,7 @@ export default function ConfigEditor({
            });
          }}
        />
-      </div>
-      {/* </Activity> */}
+      </Activity>
    </>
  );
 }
@@ -126,9 +116,8 @@ function ExpandedEditor({

  return (
    <ViewTransition
-      update={{[CONFIG_PANEL_TRANSITION]: 'slide-in', default: 'none'}}>
-      {/* enter={{[CONFIG_PANEL_TRANSITION]: 'slide-in', default: 'none'}}
-      exit={{[CONFIG_PANEL_TRANSITION]: 'slide-out', default: 'none'}}> */}
+      enter={{[CONFIG_PANEL_TRANSITION]: 'slide-in', default: 'none'}}
+      exit={{[CONFIG_PANEL_TRANSITION]: 'slide-out', default: 'none'}}>
      <Resizable
        minWidth={300}
        maxWidth={600}
--- a/compiler/apps/playground/next-env.d.ts
+++ b/compiler/apps/playground/next-env.d.ts
@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
--- a/compiler/apps/playground/package.json
+++ b/compiler/apps/playground/package.json
@@ -35,13 +35,13 @@
    "lru-cache": "^11.2.2",
    "lz-string": "^1.5.0",
    "monaco-editor": "^0.52.0",
-    "next": "15.5.9",
+    "next": "15.6.0-canary.7",
    "notistack": "^3.0.0-alpha.7",
    "prettier": "^3.3.3",
    "pretty-format": "^29.3.1",
    "re-resizable": "^6.9.16",
-    "react": "19.2.3",
-    "react-dom": "19.2.3"
+    "react": "19.2",
+    "react-dom": "19.2"
  },
  "devDependencies": {
    "@types/node": "18.11.9",
--- a/compiler/apps/playground/tsconfig.json
+++ b/compiler/apps/playground/tsconfig.json
@@ -19,7 +19,7 @@
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
-    "jsx": "preserve",
+    "jsx": "react-jsx",
    "incremental": true,
    "plugins": [
      {
--- a/compiler/apps/playground/yarn.lock
+++ b/compiler/apps/playground/yarn.lock
@@ -715,10 +715,10 @@
  dependencies:
    "@monaco-editor/loader" "^1.6.1"

-"@next/env@15.5.9":
-  version "15.5.9"
-  resolved "https://registry.yarnpkg.com/@next/env/-/env-15.5.9.tgz#53c2c34dc17cd87b61f70c6cc211e303123b2ab8"
-  integrity sha512-4GlTZ+EJM7WaW2HEZcyU317tIQDjkQIyENDLxYJfSWlfqguN+dHkZgyQTV/7ykvobU7yEH5gKvreNrH4B6QgIg==
+"@next/env@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/env/-/env-15.6.0-canary.7.tgz#cdbf2967a9437ef09eef755e203f315acc4d8d8f"
+  integrity sha512-LNZ7Yd3Cl9rKvjYdeJmszf2HmSDP76SQmfafKep2Ux16ZXKoN5OjwVHFTltKNdsB3vt2t+XJzLP2rhw5lBoFBA==

 "@next/eslint-plugin-next@15.5.2":
  version "15.5.2"
@@ -727,45 +727,45 @@
  dependencies:
    fast-glob "3.3.1"

-"@next/swc-darwin-arm64@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-darwin-arm64/-/swc-darwin-arm64-15.5.7.tgz#f0c9ccfec2cd87cbd4b241ce4c779a7017aed958"
-  integrity sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw==
+"@next/swc-darwin-arm64@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-darwin-arm64/-/swc-darwin-arm64-15.6.0-canary.7.tgz#628cd34ce9120000f1cb5b08963426431174fc57"
+  integrity sha512-POsBrxhrR3qvqXV+JZ6ZoBc8gJf8rhYe+OedceI1piPVqtJYOJa3EB4eaqcc+kMsllKRrH/goNlhLwtyhE+0Qg==

-"@next/swc-darwin-x64@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-darwin-x64/-/swc-darwin-x64-15.5.7.tgz#18009e9fcffc5c0687cc9db24182ddeac56280d9"
-  integrity sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg==
+"@next/swc-darwin-x64@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-darwin-x64/-/swc-darwin-x64-15.6.0-canary.7.tgz#37d4ebab14da74a2f8028daf6d76aab410153e06"
+  integrity sha512-lmk9ysBuSiPlAJZTCo/3O4mXNFosg6EDIf4GrmynIwCG2as6/KxzyD1WqFp56Exp8eFDjP7SFapD10sV43vCsA==

-"@next/swc-linux-arm64-gnu@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-15.5.7.tgz#fe7c7e08264cf522d4e524299f6d3e63d68d579a"
-  integrity sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA==
+"@next/swc-linux-arm64-gnu@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-15.6.0-canary.7.tgz#ce700cc0e0d24763136838223105a524b36694fa"
+  integrity sha512-why8k6d0SBm3AKoOD5S7ir3g+BF34l9oFKIoZrLaZaKBvNGpFcjc7Ovc2TunNMeaMJzv9k1dHYSap0EI5oSuzg==

-"@next/swc-linux-arm64-musl@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-15.5.7.tgz#94228fe293475ec34a5a54284e1056876f43a3cf"
-  integrity sha512-nfymt+SE5cvtTrG9u1wdoxBr9bVB7mtKTcj0ltRn6gkP/2Nu1zM5ei8rwP9qKQP0Y//umK+TtkKgNtfboBxRrw==
+"@next/swc-linux-arm64-musl@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-15.6.0-canary.7.tgz#c791b8e15bf2c338b4cc0387fe7afb3ef83ecfcf"
+  integrity sha512-HzvTRsKvYj32Va4YuJN3n3xOxvk+6QwB63d/EsgmdkeA/vrqciUAmJDYpuzZEvRc3Yp2nyPq8KZxtHAr6ISZ2Q==

-"@next/swc-linux-x64-gnu@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-15.5.7.tgz#078c71201dfe7fcfb8fa6dc92aae6c94bc011cdc"
-  integrity sha512-hvXcZvCaaEbCZcVzcY7E1uXN9xWZfFvkNHwbe/n4OkRhFWrs1J1QV+4U1BN06tXLdaS4DazEGXwgqnu/VMcmqw==
+"@next/swc-linux-x64-gnu@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-15.6.0-canary.7.tgz#c01c3a3d8e71660c49298dd053d078379b6b5919"
+  integrity sha512-6yRFrg2qWXOqa+1BI53J9EmHWFzKg9U2r+5R7n7BFUp8PH5SC92WBsmYTnh/RkvAYvdupiVzMervwwswCs6kFg==

-"@next/swc-linux-x64-musl@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-15.5.7.tgz#72947f5357f9226292353e0bb775643da3c7a182"
-  integrity sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA==
+"@next/swc-linux-x64-musl@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-15.6.0-canary.7.tgz#3f4b39faef4a5f88b13e4c726b008ddc9717f819"
+  integrity sha512-O/JjvOvNK/Wao/OIQaA6evDkxkmFFQgJ1/hI1dVk6/PAeKmW2/Q+6Dodh97eAkOwedS1ZdQl2mojf87TzLvzdQ==

-"@next/swc-win32-arm64-msvc@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-15.5.7.tgz#397b912cd51c6a80e32b9c0507ecd82514353941"
-  integrity sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ==
+"@next/swc-win32-arm64-msvc@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-15.6.0-canary.7.tgz#9bc5da0907b7ce67eedda02a6d56a09d9a539ccf"
+  integrity sha512-p9DvrDgnePofZCtiWVY7qZtwXxiOGJlAyy2LoGPYSGOUDhjbTG8j6XMUFXpV9UwpH+l7st522psO1BVzbpT8IQ==

-"@next/swc-win32-x64-msvc@15.5.7":
-  version "15.5.7"
-  resolved "https://registry.yarnpkg.com/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-15.5.7.tgz#e02b543d9dc6c1631d4ac239cb1177245dfedfe4"
-  integrity sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw==
+"@next/swc-win32-x64-msvc@15.6.0-canary.7":
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-15.6.0-canary.7.tgz#5b271c591ccbe67d5fa966dd22db86c547414fd1"
+  integrity sha512-f1ywT3xWu4StWKA1mZRyGfelu/h+W0OEEyBxQNXzXyYa0VGZb9LyCNb5cYoNKBm0Bw18Hp1PVe0bHuusemGCcw==

 "@nodelib/fs.scandir@2.1.5":
  version "2.1.5"
@@ -3204,25 +3204,25 @@ natural-compare@^1.4.0:
  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
  integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==

-next@15.5.9:
-  version "15.5.9"
-  resolved "https://registry.yarnpkg.com/next/-/next-15.5.9.tgz#1b80d05865cc27e710fb4dcfc6fd9e726ed12ad4"
-  integrity sha512-agNLK89seZEtC5zUHwtut0+tNrc0Xw4FT/Dg+B/VLEo9pAcS9rtTKpek3V6kVcVwsB2YlqMaHdfZL4eLEVYuCg==
+next@15.6.0-canary.7:
+  version "15.6.0-canary.7"
+  resolved "https://registry.yarnpkg.com/next/-/next-15.6.0-canary.7.tgz#bfc2ac3c9a78e23d550c303d18247a263e6b5bc1"
+  integrity sha512-4ukX2mxat9wWT6E0Gw/3TOR9ULV1q399E42F86cwsPSFgTWa04ABhcTqO0r9J/QR1YWPR8WEgh9qUzmWA/1yEw==
  dependencies:
-    "@next/env" "15.5.9"
+    "@next/env" "15.6.0-canary.7"
    "@swc/helpers" "0.5.15"
    caniuse-lite "^1.0.30001579"
    postcss "8.4.31"
    styled-jsx "5.1.6"
  optionalDependencies:
-    "@next/swc-darwin-arm64" "15.5.7"
-    "@next/swc-darwin-x64" "15.5.7"
-    "@next/swc-linux-arm64-gnu" "15.5.7"
-    "@next/swc-linux-arm64-musl" "15.5.7"
-    "@next/swc-linux-x64-gnu" "15.5.7"
-    "@next/swc-linux-x64-musl" "15.5.7"
-    "@next/swc-win32-arm64-msvc" "15.5.7"
-    "@next/swc-win32-x64-msvc" "15.5.7"
+    "@next/swc-darwin-arm64" "15.6.0-canary.7"
+    "@next/swc-darwin-x64" "15.6.0-canary.7"
+    "@next/swc-linux-arm64-gnu" "15.6.0-canary.7"
+    "@next/swc-linux-arm64-musl" "15.6.0-canary.7"
+    "@next/swc-linux-x64-gnu" "15.6.0-canary.7"
+    "@next/swc-linux-x64-musl" "15.6.0-canary.7"
+    "@next/swc-win32-arm64-msvc" "15.6.0-canary.7"
+    "@next/swc-win32-x64-msvc" "15.6.0-canary.7"
    sharp "^0.34.3"

 node-releases@^2.0.18:
@@ -3582,10 +3582,10 @@ re-resizable@^6.9.16:
  resolved "https://registry.yarnpkg.com/re-resizable/-/re-resizable-6.10.0.tgz#d684a096ab438f1a93f59ad3a580a206b0ce31ee"
  integrity sha512-hysSK0xmA5nz24HBVztlk4yCqCLCvS32E6ZpWxVKop9x3tqCa4yAj1++facrmkOf62JsJHjmjABdKxXofYioCw==

-react-dom@19.2.3:
-  version "19.2.3"
-  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-19.2.3.tgz#f0b61d7e5c4a86773889fcc1853af3ed5f215b17"
-  integrity sha512-yELu4WmLPw5Mr/lmeEpox5rw3RETacE++JgHqQzd2dg+YbJuat3jH4ingc+WPZhxaoFzdv9y33G+F7Nl5O0GBg==
+react-dom@19.2:
+  version "19.2.0"
+  resolved "https://registry.npmjs.org/react-dom/-/react-dom-19.2.0.tgz#00ed1e959c365e9a9d48f8918377465466ec3af8"
+  integrity sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==
  dependencies:
    scheduler "^0.27.0"

@@ -3599,10 +3599,10 @@ react-is@^18.0.0:
  resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.3.1.tgz#e83557dc12eae63a99e003a46388b1dcbb44db7e"
  integrity sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==

-react@19.2.3:
-  version "19.2.3"
-  resolved "https://registry.yarnpkg.com/react/-/react-19.2.3.tgz#d83e5e8e7a258cf6b4fe28640515f99b87cd19b8"
-  integrity sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==
+react@19.2:
+  version "19.2.0"
+  resolved "https://registry.npmjs.org/react/-/react-19.2.0.tgz#d33dd1721698f4376ae57a54098cb47fc75d93a5"
+  integrity sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==

 read-cache@^1.0.0:
  version "1.0.0"
--- a/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts
@@ -304,30 +304,6 @@ export class CompilerError extends Error {
  disabledDetails: Array<CompilerErrorDetail | CompilerDiagnostic> = [];
  printedMessage: string | null = null;

-  static simpleInvariant(
-    condition: unknown,
-    options: {
-      reason: CompilerDiagnosticOptions['reason'];
-      description?: CompilerDiagnosticOptions['description'];
-      loc: SourceLocation;
-    },
-  ): asserts condition {
-    if (!condition) {
-      const errors = new CompilerError();
-      errors.pushDiagnostic(
-        CompilerDiagnostic.create({
-          reason: options.reason,
-          description: options.description ?? null,
-          category: ErrorCategory.Invariant,
-        }).withDetails({
-          kind: 'error',
-          loc: options.loc,
-          message: options.reason,
-        }),
-      );
-      throw errors;
-    }
-  }
  static invariant(
    condition: unknown,
    options: Omit<CompilerDiagnosticOptions, 'category'>,
@@ -600,9 +576,7 @@ function printErrorSummary(category: ErrorCategory, message: string): string {
    case ErrorCategory.Suppression:
    case ErrorCategory.Syntax:
    case ErrorCategory.UseMemo:
-    case ErrorCategory.VoidUseMemo:
-    case ErrorCategory.MemoDependencies:
-    case ErrorCategory.EffectExhaustiveDependencies: {
+    case ErrorCategory.VoidUseMemo: {
      heading = 'Error';
      break;
    }
@@ -660,10 +634,6 @@ export enum ErrorCategory {
   * Checks that manual memoization is preserved
   */
  PreserveManualMemo = 'PreserveManualMemo',
-  /**
-   * Checks for exhaustive useMemo/useCallback dependencies without extraneous values
-   */
-  MemoDependencies = 'MemoDependencies',
  /**
   * Checks for known incompatible libraries
   */
@@ -684,10 +654,6 @@ export enum ErrorCategory {
   * Checks for memoized effect deps
   */
  EffectDependencies = 'EffectDependencies',
-  /**
-   * Checks for exhaustive and extraneous effect dependencies
-   */
-  EffectExhaustiveDependencies = 'EffectExhaustiveDependencies',
  /**
   * Checks for no setState in effect bodies
   */
@@ -843,16 +809,6 @@ function getRuleForCategoryImpl(category: ErrorCategory): LintRule {
        preset: LintRulePreset.Off,
      };
    }
-    case ErrorCategory.EffectExhaustiveDependencies: {
-      return {
-        category,
-        severity: ErrorSeverity.Error,
-        name: 'exhaustive-effect-dependencies',
-        description:
-          'Validates that effect dependencies are exhaustive and without extraneous values',
-        preset: LintRulePreset.Off,
-      };
-    }
    case ErrorCategory.EffectDerivationsOfState: {
      return {
        category,
@@ -869,9 +825,7 @@ function getRuleForCategoryImpl(category: ErrorCategory): LintRule {
        severity: ErrorSeverity.Error,
        name: 'set-state-in-effect',
        description:
-          'Validates against calling setState synchronously in an effect. ' +
-          'This can indicate non-local derived data, a derived event pattern, or ' +
-          'improper external data synchronization.',
+          'Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance',
        preset: LintRulePreset.Recommended,
      };
    }
@@ -1077,24 +1031,6 @@ function getRuleForCategoryImpl(category: ErrorCategory): LintRule {
        preset: LintRulePreset.RecommendedLatest,
      };
    }
-    case ErrorCategory.MemoDependencies: {
-      return {
-        category,
-        severity: ErrorSeverity.Error,
-        name: 'memo-dependencies',
-        description:
-          'Validates that useMemo() and useCallback() specify comprehensive dependencies without extraneous values. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
-        /**
-         * TODO: the "MemoDependencies" rule largely reimplements the "exhaustive-deps" non-compiler rule,
-         * allowing the compiler to ensure it does not regress change behavior due to different dependencies.
-         * We previously relied on the source having ESLint suppressions for any exhaustive-deps violations,
-         * but it's more reliable to verify it within the compiler.
-         *
-         * Long-term we should de-duplicate these implementations.
-         */
-        preset: LintRulePreset.Off,
-      };
-    }
    case ErrorCategory.IncompatibleLibrary: {
      return {
        category,
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
@@ -102,25 +102,14 @@ export type PluginOptions = Partial<{

  panicThreshold: PanicThresholdOptions;

-  /**
-   * @deprecated
-   *
+  /*
   * When enabled, Forget will continue statically analyzing and linting code, but skip over codegen
   * passes.
   *
-   * NOTE: ignored if `outputMode` is specified
-   *
   * Defaults to false
   */
  noEmit: boolean;

-  /**
-   * If specified, overrides `noEmit` and controls the output mode of the compiler.
-   *
-   * Defaults to null
-   */
-  outputMode: CompilerOutputMode | null;
-
  /*
   * Determines the strategy for determining which functions to compile. Note that regardless of
   * which mode is enabled, a component can be opted out by adding the string literal
@@ -223,19 +212,6 @@ const CompilationModeSchema = z.enum([

 export type CompilationMode = z.infer<typeof CompilationModeSchema>;

-const CompilerOutputModeSchema = z.enum([
-  // Build optimized for SSR, with client features removed
-  'ssr',
-  // Build optimized for the client, with auto memoization
-  'client',
-  // Build optimized for the client without auto memo
-  'client-no-memo',
-  // Lint mode, the output is unused but validations should run
-  'lint',
-]);
-
-export type CompilerOutputMode = z.infer<typeof CompilerOutputModeSchema>;
-
 /**
 * Represents 'events' that may occur during compilation. Events are only
 * recorded when a logger is set (through the config).
@@ -317,7 +293,6 @@ export const defaultOptions: ParsedPluginOptions = {
  logger: null,
  gating: null,
  noEmit: false,
-  outputMode: null,
  dynamicGating: null,
  eslintSuppressionRules: null,
  flowSuppressions: true,
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts
@@ -8,7 +8,7 @@
 import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
 import prettyFormat from 'pretty-format';
-import {CompilerOutputMode, Logger, ProgramContext} from '.';
+import {Logger, ProgramContext} from '.';
 import {
  HIRFunction,
  ReactiveFunction,
@@ -24,6 +24,7 @@ import {
  pruneUnusedLabelsHIR,
 } from '../HIR';
 import {
+  CompilerMode,
  Environment,
  EnvironmentConfig,
  ReactFunctionType,
@@ -104,9 +105,6 @@ import {inferMutationAliasingRanges} from '../Inference/InferMutationAliasingRan
 import {validateNoDerivedComputationsInEffects} from '../Validation/ValidateNoDerivedComputationsInEffects';
 import {validateNoDerivedComputationsInEffects_exp} from '../Validation/ValidateNoDerivedComputationsInEffects_exp';
 import {nameAnonymousFunctions} from '../Transform/NameAnonymousFunctions';
-import {optimizeForSSR} from '../Optimization/OptimizeForSSR';
-import {validateExhaustiveDependencies} from '../Validation/ValidateExhaustiveDependencies';
-import {validateSourceLocations} from '../Validation/ValidateSourceLocations';

 export type CompilerPipelineValue =
  | {kind: 'ast'; name: string; value: CodegenFunction}
@@ -120,7 +118,7 @@ function run(
  >,
  config: EnvironmentConfig,
  fnType: ReactFunctionType,
-  mode: CompilerOutputMode,
+  mode: CompilerMode,
  programContext: ProgramContext,
  logger: Logger | null,
  filename: string | null,
@@ -170,7 +168,7 @@ function runWithEnvironment(
  validateUseMemo(hir).unwrap();

  if (
-    env.enableDropManualMemoization &&
+    env.isInferredMemoEnabled &&
    !env.config.enablePreserveExistingManualUseMemo &&
    !env.config.disableMemoizationForDebugging &&
    !env.config.enableChangeDetectionForDebugging
@@ -206,7 +204,7 @@ function runWithEnvironment(
  inferTypes(hir);
  log({kind: 'hir', name: 'InferTypes', value: hir});

-  if (env.enableValidations) {
+  if (env.isInferredMemoEnabled) {
    if (env.config.validateHooksUsage) {
      validateHooksUsage(hir).unwrap();
    }
@@ -232,17 +230,12 @@ function runWithEnvironment(

  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
-  if (env.enableValidations) {
+  if (env.isInferredMemoEnabled) {
    if (mutabilityAliasingErrors.isErr()) {
      throw mutabilityAliasingErrors.unwrapErr();
    }
  }

-  if (env.outputMode === 'ssr') {
-    optimizeForSSR(hir);
-    log({kind: 'hir', name: 'OptimizeForSSR', value: hir});
-  }
-
  // Note: Has to come after infer reference effects because "dead" code may still affect inference
  deadCodeElimination(hir);
  log({kind: 'hir', name: 'DeadCodeElimination', value: hir});
@@ -259,14 +252,14 @@ function runWithEnvironment(
    isFunctionExpression: false,
  });
  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
-  if (env.enableValidations) {
+  if (env.isInferredMemoEnabled) {
    if (mutabilityAliasingRangeErrors.isErr()) {
      throw mutabilityAliasingRangeErrors.unwrapErr();
    }
    validateLocalsNotReassignedAfterRender(hir);
  }

-  if (env.enableValidations) {
+  if (env.isInferredMemoEnabled) {
    if (env.config.assertValidMutableRanges) {
      assertValidMutableRanges(hir);
    }
@@ -279,20 +272,19 @@ function runWithEnvironment(
      validateNoSetStateInRender(hir).unwrap();
    }

-    if (
-      env.config.validateNoDerivedComputationsInEffects_exp &&
-      env.outputMode === 'lint'
-    ) {
-      env.logErrors(validateNoDerivedComputationsInEffects_exp(hir));
-    } else if (env.config.validateNoDerivedComputationsInEffects) {
+    if (env.config.validateNoDerivedComputationsInEffects) {
      validateNoDerivedComputationsInEffects(hir);
    }

-    if (env.config.validateNoSetStateInEffects && env.outputMode === 'lint') {
+    if (env.config.validateNoDerivedComputationsInEffects_exp) {
+      validateNoDerivedComputationsInEffects_exp(hir);
+    }
+
+    if (env.config.validateNoSetStateInEffects) {
      env.logErrors(validateNoSetStateInEffects(hir, env));
    }

-    if (env.config.validateNoJSXInTryStatements && env.outputMode === 'lint') {
+    if (env.config.validateNoJSXInTryStatements) {
      env.logErrors(validateNoJSXInTryStatement(hir));
    }

@@ -306,16 +298,6 @@ function runWithEnvironment(
  inferReactivePlaces(hir);
  log({kind: 'hir', name: 'InferReactivePlaces', value: hir});

-  if (env.enableValidations) {
-    if (
-      env.config.validateExhaustiveMemoizationDependencies ||
-      env.config.validateExhaustiveEffectDependencies
-    ) {
-      // NOTE: this relies on reactivity inference running first
-      validateExhaustiveDependencies(hir).unwrap();
-    }
-  }
-
  rewriteInstructionKindsBasedOnReassignment(hir);
  log({
    kind: 'hir',
@@ -323,15 +305,11 @@ function runWithEnvironment(
    value: hir,
  });

-  if (
-    env.enableValidations &&
-    env.config.validateStaticComponents &&
-    env.outputMode === 'lint'
-  ) {
-    env.logErrors(validateStaticComponents(hir));
-  }
+  if (env.isInferredMemoEnabled) {
+    if (env.config.validateStaticComponents) {
+      env.logErrors(validateStaticComponents(hir));
+    }

-  if (env.enableMemoization) {
    /**
     * Only create reactive scopes (which directly map to generated memo blocks)
     * if inferred memoization is enabled. This makes all later passes which
@@ -581,10 +559,6 @@ function runWithEnvironment(
    log({kind: 'ast', name: 'Codegen (outlined)', value: outlined.fn});
  }

-  if (env.config.validateSourceLocations) {
-    validateSourceLocations(func, ast).unwrap();
-  }
-
  /**
   * This flag should be only set for unit / fixture tests to check
   * that Forget correctly handles unexpected errors (e.g. exceptions
@@ -603,7 +577,7 @@ export function compileFn(
  >,
  config: EnvironmentConfig,
  fnType: ReactFunctionType,
-  mode: CompilerOutputMode,
+  mode: CompilerMode,
  programContext: ProgramContext,
  logger: Logger | null,
  filename: string | null,
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
@@ -24,7 +24,6 @@ import {
  validateRestrictedImports,
 } from './Imports';
 import {
-  CompilerOutputMode,
  CompilerReactTarget,
  ParsedPluginOptions,
  PluginOptions,
@@ -400,15 +399,7 @@ export function compileProgram(
   */
  const suppressions = findProgramSuppressions(
    pass.comments,
-    /*
-     * If the compiler is validating hooks rules and exhaustive memo dependencies, we don't need to check
-     * for React ESLint suppressions
-     */
-    pass.opts.environment.validateExhaustiveMemoizationDependencies &&
-      pass.opts.environment.validateHooksUsage
-      ? null
-      : (pass.opts.eslintSuppressionRules ?? DEFAULT_ESLINT_SUPPRESSIONS),
-    // Always bail on Flow suppressions
+    pass.opts.eslintSuppressionRules ?? DEFAULT_ESLINT_SUPPRESSIONS,
    pass.opts.flowSuppressions,
  );

@@ -430,17 +421,9 @@ export function compileProgram(
  );
  const compiledFns: Array<CompileResult> = [];

-  // outputMode takes precedence if specified
-  const outputMode: CompilerOutputMode =
-    pass.opts.outputMode ?? (pass.opts.noEmit ? 'lint' : 'client');
  while (queue.length !== 0) {
    const current = queue.shift()!;
-    const compiled = processFn(
-      current.fn,
-      current.fnType,
-      programContext,
-      outputMode,
-    );
+    const compiled = processFn(current.fn, current.fnType, programContext);

    if (compiled != null) {
      for (const outlined of compiled.outlined) {
@@ -598,7 +581,6 @@ function processFn(
  fn: BabelFn,
  fnType: ReactFunctionType,
  programContext: ProgramContext,
-  outputMode: CompilerOutputMode,
 ): null | CodegenFunction {
  let directives: {
    optIn: t.Directive | null;
@@ -634,27 +616,18 @@ function processFn(
  }

  let compiledFn: CodegenFunction;
-  const compileResult = tryCompileFunction(
-    fn,
-    fnType,
-    programContext,
-    outputMode,
-  );
+  const compileResult = tryCompileFunction(fn, fnType, programContext);
  if (compileResult.kind === 'error') {
    if (directives.optOut != null) {
      logError(compileResult.error, programContext, fn.node.loc ?? null);
    } else {
      handleError(compileResult.error, programContext, fn.node.loc ?? null);
    }
-    if (outputMode === 'client') {
-      const retryResult = retryCompileFunction(fn, fnType, programContext);
-      if (retryResult == null) {
-        return null;
-      }
-      compiledFn = retryResult;
-    } else {
+    const retryResult = retryCompileFunction(fn, fnType, programContext);
+    if (retryResult == null) {
      return null;
    }
+    compiledFn = retryResult;
  } else {
    compiledFn = compileResult.compiledFn;
  }
@@ -690,7 +663,7 @@ function processFn(

  if (programContext.hasModuleScopeOptOut) {
    return null;
-  } else if (programContext.opts.outputMode === 'lint') {
+  } else if (programContext.opts.noEmit) {
    /**
     * inferEffectDependencies + noEmit is currently only used for linting. In
     * this mode, add source locations for where the compiler *can* infer effect
@@ -720,7 +693,6 @@ function tryCompileFunction(
  fn: BabelFn,
  fnType: ReactFunctionType,
  programContext: ProgramContext,
-  outputMode: CompilerOutputMode,
 ):
  | {kind: 'compile'; compiledFn: CodegenFunction}
  | {kind: 'error'; error: unknown} {
@@ -747,7 +719,7 @@ function tryCompileFunction(
        fn,
        programContext.opts.environment,
        fnType,
-        outputMode,
+        'all_features',
        programContext,
        programContext.opts.logger,
        programContext.filename,
@@ -785,7 +757,7 @@ function retryCompileFunction(
      fn,
      environment,
      fnType,
-      'client-no-memo',
+      'no_inferred_memo',
      programContext,
      programContext.opts.logger,
      programContext.filename,
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Suppression.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Suppression.ts
@@ -78,7 +78,7 @@ export function filterSuppressionsThatAffectFunction(

 export function findProgramSuppressions(
  programComments: Array<t.Comment>,
-  ruleNames: Array<string> | null,
+  ruleNames: Array<string>,
  flowSuppressions: boolean,
 ): Array<SuppressionRange> {
  const suppressionRanges: Array<SuppressionRange> = [];
@@ -89,7 +89,7 @@ export function findProgramSuppressions(
  let disableNextLinePattern: RegExp | null = null;
  let disablePattern: RegExp | null = null;
  let enablePattern: RegExp | null = null;
-  if (ruleNames != null && ruleNames.length !== 0) {
+  if (ruleNames.length !== 0) {
    const rulePattern = `(${ruleNames.join('|')})`;
    disableNextLinePattern = new RegExp(
      `eslint-disable-next-line ${rulePattern}`,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
@@ -4026,7 +4026,6 @@ function lowerAssignment(
          pattern: {
            kind: 'ArrayPattern',
            items,
-            loc: lvalue.node.loc ?? GeneratedSource,
          },
        },
        value,
@@ -4204,7 +4203,6 @@ function lowerAssignment(
          pattern: {
            kind: 'ObjectPattern',
            properties,
-            loc: lvalue.node.loc ?? GeneratedSource,
          },
        },
        value,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts
@@ -9,7 +9,7 @@ import * as t from '@babel/types';
 import {ZodError, z} from 'zod/v4';
 import {fromZodError} from 'zod-validation-error/v4';
 import {CompilerError} from '../CompilerError';
-import {CompilerOutputMode, Logger, ProgramContext} from '../Entrypoint';
+import {Logger, ProgramContext} from '../Entrypoint';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
  DEFAULT_GLOBALS,
@@ -51,7 +51,6 @@ import {Scope as BabelScope, NodePath} from '@babel/traverse';
 import {TypeSchema} from './TypeSchema';
 import {FlowTypeEnv} from '../Flood/Types';
 import {defaultModuleTypeProvider} from './DefaultModuleTypeProvider';
-import {assertExhaustive} from '../Utils/utils';

 export const ReactElementSymbolSchema = z.object({
  elementSymbol: z.union([
@@ -218,23 +217,6 @@ export const EnvironmentConfigSchema = z.object({
   */
  validatePreserveExistingMemoizationGuarantees: z.boolean().default(true),

-  /**
-   * Validate that dependencies supplied to manual memoization calls are exhaustive.
-   */
-  validateExhaustiveMemoizationDependencies: z.boolean().default(true),
-
-  /**
-   * Validate that dependencies supplied to effect hooks are exhaustive.
-   * Can be:
-   * - 'off': No validation (default)
-   * - 'all': Validate and report both missing and extra dependencies
-   * - 'missing-only': Only report missing dependencies
-   * - 'extra-only': Only report extra/unnecessary dependencies
-   */
-  validateExhaustiveEffectDependencies: z
-    .enum(['off', 'all', 'missing-only', 'extra-only'])
-    .default('off'),
-
  /**
   * When this is true, rather than pruning existing manual memoization but ensuring or validating
   * that the memoized values remain memoized, the compiler will simply not prune existing calls to
@@ -330,12 +312,6 @@ export const EnvironmentConfigSchema = z.object({
   */
  validateNoSetStateInRender: z.boolean().default(true),

-  /**
-   * When enabled, changes the behavior of validateNoSetStateInRender to recommend
-   * using useKeyedState instead of the manual pattern for resetting state.
-   */
-  enableUseKeyedState: z.boolean().default(false),
-
  /**
   * Validates that setState is not called synchronously within an effect (useEffect and friends).
   * Scheduling a setState (with an event listener, subscription, etc) is valid.
@@ -388,13 +364,6 @@ export const EnvironmentConfigSchema = z.object({
  validateNoCapitalizedCalls: z.nullable(z.array(z.string())).default(null),
  validateBlocklistedImports: z.nullable(z.array(z.string())).default(null),

-  /**
-   * Validates that AST nodes generated during codegen have proper source locations.
-   * This is useful for debugging issues with source maps and Istanbul coverage.
-   * When enabled, the compiler will error if important source locations are missing in the generated AST.
-   */
-  validateSourceLocations: z.boolean().default(false),
-
  /**
   * Validate against impure functions called during render
   */
@@ -696,35 +665,11 @@ export const EnvironmentConfigSchema = z.object({
  validateNoDynamicallyCreatedComponentsOrHooks: z.boolean().default(false),

  /**
-   * When enabled, allows setState calls in effects based on valid patterns involving refs:
-   * - Allow setState where the value being set is derived from a ref. This is useful where
-   *   state needs to take into account layer information, and a layout effect reads layout
-   *   data from a ref and sets state.
-   * - Allow conditionally calling setState after manually comparing previous/new values
-   *   for changes via a ref. Relying on effect deps is insufficient for non-primitive values,
-   *   so a ref is generally required to manually track previous values and compare prev/next
-   *   for meaningful changes before setting state.
+   * When enabled, allows setState calls in effects when the value being set is
+   * derived from a ref. This is useful for patterns where initial layout measurements
+   * from refs need to be stored in state during mount.
   */
  enableAllowSetStateFromRefsInEffects: z.boolean().default(true),
-
-  /**
-   * When enabled, provides verbose error messages for setState calls within effects,
-   * presenting multiple possible fixes to the user/agent since we cannot statically
-   * determine which specific use-case applies:
-   * 1. Non-local derived data - requires restructuring state ownership
-   * 2. Derived event pattern - detecting when a prop changes
-   * 3. Force update / external sync - should use useSyncExternalStore
-   */
-  enableVerboseNoSetStateInEffect: z.boolean().default(false),
-
-  /**
-   * Enables inference of event handler types for JSX props on built-in DOM elements.
-   * When enabled, functions passed to event handler props (props starting with "on")
-   * on primitive JSX tags are inferred to have the BuiltinEventHandlerId type, which
-   * allows ref access within those functions since DOM event handlers are guaranteed
-   * by React to only execute in response to events, not during render.
-   */
-  enableInferEventHandlers: z.boolean().default(false),
 });

 export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
@@ -764,7 +709,7 @@ export class Environment {
  code: string | null;
  config: EnvironmentConfig;
  fnType: ReactFunctionType;
-  outputMode: CompilerOutputMode;
+  compilerMode: CompilerMode;
  programContext: ProgramContext;
  hasFireRewrite: boolean;
  hasInferredEffect: boolean;
@@ -779,7 +724,7 @@ export class Environment {
  constructor(
    scope: BabelScope,
    fnType: ReactFunctionType,
-    outputMode: CompilerOutputMode,
+    compilerMode: CompilerMode,
    config: EnvironmentConfig,
    contextIdentifiers: Set<t.Identifier>,
    parentFunction: NodePath<t.Function>, // the outermost function being compiled
@@ -790,7 +735,7 @@ export class Environment {
  ) {
    this.#scope = scope;
    this.fnType = fnType;
-    this.outputMode = outputMode;
+    this.compilerMode = compilerMode;
    this.config = config;
    this.filename = filename;
    this.code = code;
@@ -886,65 +831,8 @@ export class Environment {
    return this.#flowTypeEnvironment;
  }

-  get enableDropManualMemoization(): boolean {
-    switch (this.outputMode) {
-      case 'lint': {
-        // linting drops to be more compatible with compiler analysis
-        return true;
-      }
-      case 'client':
-      case 'ssr': {
-        return true;
-      }
-      case 'client-no-memo': {
-        return false;
-      }
-      default: {
-        assertExhaustive(
-          this.outputMode,
-          `Unexpected output mode '${this.outputMode}'`,
-        );
-      }
-    }
-  }
-
-  get enableMemoization(): boolean {
-    switch (this.outputMode) {
-      case 'client':
-      case 'lint': {
-        // linting also enables memoization so that we can check if manual memoization is preserved
-        return true;
-      }
-      case 'ssr':
-      case 'client-no-memo': {
-        return false;
-      }
-      default: {
-        assertExhaustive(
-          this.outputMode,
-          `Unexpected output mode '${this.outputMode}'`,
-        );
-      }
-    }
-  }
-
-  get enableValidations(): boolean {
-    switch (this.outputMode) {
-      case 'client':
-      case 'lint':
-      case 'ssr': {
-        return true;
-      }
-      case 'client-no-memo': {
-        return false;
-      }
-      default: {
-        assertExhaustive(
-          this.outputMode,
-          `Unexpected output mode '${this.outputMode}'`,
-        );
-      }
-    }
+  get isInferredMemoEnabled(): boolean {
+    return this.compilerMode !== 'no_inferred_memo';
  }

  get nextIdentifierId(): IdentifierId {
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts
@@ -23,14 +23,13 @@ import {
  BuiltInUseInsertionEffectHookId,
  BuiltInUseLayoutEffectHookId,
  BuiltInUseOperatorId,
-  BuiltInUseOptimisticId,
  BuiltInUseReducerId,
  BuiltInUseRefId,
  BuiltInUseStateId,
  BuiltInUseTransitionId,
  BuiltInWeakMapId,
  BuiltInWeakSetId,
-  BuiltInEffectEventId,
+  BuiltinEffectEventId,
  ReanimatedSharedValueId,
  ShapeRegistry,
  addFunction,
@@ -819,18 +818,6 @@ const REACT_APIS: Array<[string, BuiltInType]> = [
      returnValueKind: ValueKind.Frozen,
    }),
  ],
-  [
-    'useOptimistic',
-    addHook(DEFAULT_SHAPES, {
-      positionalParams: [],
-      restParam: Effect.Freeze,
-      returnType: {kind: 'Object', shapeId: BuiltInUseOptimisticId},
-      calleeEffect: Effect.Read,
-      hookKind: 'useOptimistic',
-      returnValueKind: ValueKind.Frozen,
-      returnValueReason: ValueReason.State,
-    }),
-  ],
  [
    'use',
    addFunction(
@@ -876,7 +863,7 @@ const REACT_APIS: Array<[string, BuiltInType]> = [
        returnType: {
          kind: 'Function',
          return: {kind: 'Poly'},
-          shapeId: BuiltInEffectEventId,
+          shapeId: BuiltinEffectEventId,
          isConstructor: false,
        },
        calleeEffect: Effect.Read,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/HIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/HIR.ts
@@ -694,13 +694,11 @@ export type SpreadPattern = {
 export type ArrayPattern = {
  kind: 'ArrayPattern';
  items: Array<Place | SpreadPattern | Hole>;
-  loc: SourceLocation;
 };

 export type ObjectPattern = {
  kind: 'ObjectPattern';
  properties: Array<ObjectProperty | SpreadPattern>;
-  loc: SourceLocation;
 };

 export type ObjectPropertyKey =
@@ -805,11 +803,9 @@ export type ManualMemoDependency = {
    | {
        kind: 'NamedLocal';
        value: Place;
-        constant: boolean;
      }
    | {kind: 'Global'; identifierName: string};
  path: DependencyPath;
-  loc: SourceLocation;
 };

 export type StartMemoize = {
@@ -821,11 +817,6 @@ export type StartMemoize = {
   * (e.g. useMemo without a second arg)
   */
  deps: Array<ManualMemoDependency> | null;
-  /**
-   * The source location of the dependencies argument. Used for
-   * emitting diagnostics with a suggested replacement
-   */
-  depsLoc: SourceLocation | null;
  loc: SourceLocation;
 };
 export type FinishMemoize = {
@@ -1689,28 +1680,6 @@ export function areEqualPaths(a: DependencyPath, b: DependencyPath): boolean {
    )
  );
 }
-export function isSubPath(
-  subpath: DependencyPath,
-  path: DependencyPath,
-): boolean {
-  return (
-    subpath.length <= path.length &&
-    subpath.every(
-      (item, ix) =>
-        item.property === path[ix].property &&
-        item.optional === path[ix].optional,
-    )
-  );
-}
-export function isSubPathIgnoringOptionals(
-  subpath: DependencyPath,
-  path: DependencyPath,
-): boolean {
-  return (
-    subpath.length <= path.length &&
-    subpath.every((item, ix) => item.property === path[ix].property)
-  );
-}

 export function getPlaceScope(
  id: InstructionId,
@@ -1854,10 +1823,6 @@ export function isPrimitiveType(id: Identifier): boolean {
  return id.type.kind === 'Primitive';
 }

-export function isPlainObjectType(id: Identifier): boolean {
-  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInObject';
-}
-
 export function isArrayType(id: Identifier): boolean {
  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInArray';
 }
@@ -1922,18 +1887,6 @@ export function isStartTransitionType(id: Identifier): boolean {
  );
 }

-export function isUseOptimisticType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseOptimistic'
-  );
-}
-
-export function isSetOptimisticType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetOptimistic'
-  );
-}
-
 export function isSetActionStateType(id: Identifier): boolean {
  return (
    id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetActionState'
@@ -1967,8 +1920,7 @@ export function isStableType(id: Identifier): boolean {
    isSetActionStateType(id) ||
    isDispatcherType(id) ||
    isUseRefType(id) ||
-    isStartTransitionType(id) ||
-    isSetOptimisticType(id)
+    isStartTransitionType(id)
  );
 }

@@ -1979,9 +1931,8 @@ export function isStableTypeContainer(id: Identifier): boolean {
  }
  return (
    isUseStateType(id) || // setState
-    isUseActionStateType(id) || // setActionState
+    type_.shapeId === 'BuiltInUseActionState' || // setActionState
    isUseReducerType(id) || // dispatcher
-    isUseOptimisticType(id) || // setOptimistic
    type_.shapeId === 'BuiltInUseTransition' // startTransition
  );
 }
@@ -2001,7 +1952,6 @@ export function evaluatesToStableTypeOrContainer(
      case 'useActionState':
      case 'useRef':
      case 'useTransition':
-      case 'useOptimistic':
        return true;
    }
  }
@@ -2025,11 +1975,6 @@ export function isUseInsertionEffectHookType(id: Identifier): boolean {
    id.type.shapeId === 'BuiltInUseInsertionEffectHook'
  );
 }
-export function isUseEffectEventType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseEffectEvent'
-  );
-}

 export function isUseContextHookType(id: Identifier): boolean {
  return (
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts
@@ -304,7 +304,6 @@ export type HookKind =
  | 'useTransition'
  | 'useImperativeHandle'
  | 'useEffectEvent'
-  | 'useOptimistic'
  | 'Custom';

 /*
@@ -400,15 +399,12 @@ export const BuiltInUseReducerId = 'BuiltInUseReducer';
 export const BuiltInDispatchId = 'BuiltInDispatch';
 export const BuiltInUseContextHookId = 'BuiltInUseContextHook';
 export const BuiltInUseTransitionId = 'BuiltInUseTransition';
-export const BuiltInUseOptimisticId = 'BuiltInUseOptimistic';
-export const BuiltInSetOptimisticId = 'BuiltInSetOptimistic';
 export const BuiltInStartTransitionId = 'BuiltInStartTransition';
 export const BuiltInFireId = 'BuiltInFire';
 export const BuiltInFireFunctionId = 'BuiltInFireFunction';
 export const BuiltInUseEffectEventId = 'BuiltInUseEffectEvent';
-export const BuiltInEffectEventId = 'BuiltInEffectEventFunction';
+export const BuiltinEffectEventId = 'BuiltInEffectEventFunction';
 export const BuiltInAutodepsId = 'BuiltInAutoDepsId';
-export const BuiltInEventHandlerId = 'BuiltInEventHandlerId';

 // See getReanimatedModuleType() in Globals.ts — this is part of supporting Reanimated's ref-like types
 export const ReanimatedSharedValueId = 'ReanimatedSharedValueId';
@@ -1189,25 +1185,6 @@ addObject(BUILTIN_SHAPES, BuiltInUseTransitionId, [
  ],
 ]);

-addObject(BUILTIN_SHAPES, BuiltInUseOptimisticId, [
-  ['0', {kind: 'Poly'}],
-  [
-    '1',
-    addFunction(
-      BUILTIN_SHAPES,
-      [],
-      {
-        positionalParams: [],
-        restParam: Effect.Freeze,
-        returnType: PRIMITIVE_TYPE,
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Primitive,
-      },
-      BuiltInSetOptimisticId,
-    ),
-  ],
-]);
-
 addObject(BUILTIN_SHAPES, BuiltInUseActionStateId, [
  ['0', {kind: 'Poly'}],
  [
@@ -1266,20 +1243,7 @@ addFunction(
    calleeEffect: Effect.ConditionallyMutate,
    returnValueKind: ValueKind.Mutable,
  },
-  BuiltInEffectEventId,
-);
-
-addFunction(
-  BUILTIN_SHAPES,
-  [],
-  {
-    positionalParams: [],
-    restParam: Effect.ConditionallyMutate,
-    returnType: {kind: 'Poly'},
-    calleeEffect: Effect.ConditionallyMutate,
-    returnValueKind: ValueKind.Mutable,
-  },
-  BuiltInEventHandlerId,
+  BuiltinEffectEventId,
 );

 /**
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/visitors.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/visitors.ts
@@ -11,7 +11,6 @@ import {
  BasicBlock,
  BlockId,
  Instruction,
-  InstructionKind,
  InstructionValue,
  makeInstructionId,
  Pattern,
@@ -33,32 +32,6 @@ export function* eachInstructionLValue(
  yield* eachInstructionValueLValue(instr.value);
 }

-export function* eachInstructionLValueWithKind(
-  instr: ReactiveInstruction,
-): Iterable<[Place, InstructionKind]> {
-  switch (instr.value.kind) {
-    case 'DeclareContext':
-    case 'StoreContext':
-    case 'DeclareLocal':
-    case 'StoreLocal': {
-      yield [instr.value.lvalue.place, instr.value.lvalue.kind];
-      break;
-    }
-    case 'Destructure': {
-      const kind = instr.value.lvalue.kind;
-      for (const place of eachPatternOperand(instr.value.lvalue.pattern)) {
-        yield [place, kind];
-      }
-      break;
-    }
-    case 'PostfixUpdate':
-    case 'PrefixUpdate': {
-      yield [instr.value.lvalue, InstructionKind.Reassign];
-      break;
-    }
-  }
-}
-
 export function* eachInstructionValueLValue(
  value: ReactiveValue,
 ): Iterable<Place> {
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/ControlDominators.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/ControlDominators.ts
@@ -1,114 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {BlockId, computePostDominatorTree, HIRFunction, Place} from '../HIR';
-import {PostDominator} from '../HIR/Dominator';
-
-export type ControlDominators = (id: BlockId) => boolean;
-
-/**
- * Returns an object that lazily calculates whether particular blocks are controlled
- * by values of interest. Which values matter are up to the caller.
- */
-export function createControlDominators(
-  fn: HIRFunction,
-  isControlVariable: (place: Place) => boolean,
-): ControlDominators {
-  const postDominators = computePostDominatorTree(fn, {
-    includeThrowsAsExitNode: false,
-  });
-  const postDominatorFrontierCache = new Map<BlockId, Set<BlockId>>();
-
-  function isControlledBlock(id: BlockId): boolean {
-    let controlBlocks = postDominatorFrontierCache.get(id);
-    if (controlBlocks === undefined) {
-      controlBlocks = postDominatorFrontier(fn, postDominators, id);
-      postDominatorFrontierCache.set(id, controlBlocks);
-    }
-    for (const blockId of controlBlocks) {
-      const controlBlock = fn.body.blocks.get(blockId)!;
-      switch (controlBlock.terminal.kind) {
-        case 'if':
-        case 'branch': {
-          if (isControlVariable(controlBlock.terminal.test)) {
-            return true;
-          }
-          break;
-        }
-        case 'switch': {
-          if (isControlVariable(controlBlock.terminal.test)) {
-            return true;
-          }
-          for (const case_ of controlBlock.terminal.cases) {
-            if (case_.test !== null && isControlVariable(case_.test)) {
-              return true;
-            }
-          }
-          break;
-        }
-      }
-    }
-    return false;
-  }
-
-  return isControlledBlock;
-}
-
-/*
- * Computes the post-dominator frontier of @param block. These are immediate successors of nodes that
- * post-dominate @param targetId and from which execution may not reach @param block. Intuitively, these
- * are the earliest blocks from which execution branches such that it may or may not reach the target block.
- */
-function postDominatorFrontier(
-  fn: HIRFunction,
-  postDominators: PostDominator<BlockId>,
-  targetId: BlockId,
-): Set<BlockId> {
-  const visited = new Set<BlockId>();
-  const frontier = new Set<BlockId>();
-  const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
-  for (const blockId of [...targetPostDominators, targetId]) {
-    if (visited.has(blockId)) {
-      continue;
-    }
-    visited.add(blockId);
-    const block = fn.body.blocks.get(blockId)!;
-    for (const pred of block.preds) {
-      if (!targetPostDominators.has(pred)) {
-        // The predecessor does not always reach this block, we found an item on the frontier!
-        frontier.add(pred);
-      }
-    }
-  }
-  return frontier;
-}
-
-function postDominatorsOf(
-  fn: HIRFunction,
-  postDominators: PostDominator<BlockId>,
-  targetId: BlockId,
-): Set<BlockId> {
-  const result = new Set<BlockId>();
-  const visited = new Set<BlockId>();
-  const queue = [targetId];
-  while (queue.length) {
-    const currentId = queue.shift()!;
-    if (visited.has(currentId)) {
-      continue;
-    }
-    visited.add(currentId);
-    const current = fn.body.blocks.get(currentId)!;
-    for (const pred of current.preds) {
-      const predPostDominator = postDominators.get(pred) ?? pred;
-      if (predPostDominator === targetId || result.has(predPostDominator)) {
-        result.add(pred);
-      }
-      queue.push(pred);
-    }
-  }
-  return result;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts
@@ -42,7 +42,7 @@ type IdentifierSidemap = {
  functions: Map<IdentifierId, TInstruction<FunctionExpression>>;
  manualMemos: Map<IdentifierId, ManualMemoCallee>;
  react: Set<IdentifierId>;
-  maybeDepsLists: Map<IdentifierId, {loc: SourceLocation; deps: Array<Place>}>;
+  maybeDepsLists: Map<IdentifierId, Array<Place>>;
  maybeDeps: Map<IdentifierId, ManualMemoDependency>;
  optionals: Set<IdentifierId>;
 };
@@ -65,7 +65,6 @@ export function collectMaybeMemoDependencies(
          identifierName: value.binding.name,
        },
        path: [],
-        loc: value.loc,
      };
    }
    case 'PropertyLoad': {
@@ -75,7 +74,6 @@ export function collectMaybeMemoDependencies(
          root: object.root,
          // TODO: determine if the access is optional
          path: [...object.path, {property: value.property, optional}],
-          loc: value.loc,
        };
      }
      break;
@@ -94,10 +92,8 @@ export function collectMaybeMemoDependencies(
          root: {
            kind: 'NamedLocal',
            value: {...value.place},
-            constant: false,
          },
          path: [],
-          loc: value.place.loc,
        };
      }
      break;
@@ -163,10 +159,10 @@ function collectTemporaries(
    }
    case 'ArrayExpression': {
      if (value.elements.every(e => e.kind === 'Identifier')) {
-        sidemap.maybeDepsLists.set(instr.lvalue.identifier.id, {
-          loc: value.loc,
-          deps: value.elements as Array<Place>,
-        });
+        sidemap.maybeDepsLists.set(
+          instr.lvalue.identifier.id,
+          value.elements as Array<Place>,
+        );
      }
      break;
    }
@@ -186,7 +182,6 @@ function makeManualMemoizationMarkers(
  fnExpr: Place,
  env: Environment,
  depsList: Array<ManualMemoDependency> | null,
-  depsLoc: SourceLocation | null,
  memoDecl: Place,
  manualMemoId: number,
 ): [TInstruction<StartMemoize>, TInstruction<FinishMemoize>] {
@@ -202,7 +197,6 @@ function makeManualMemoizationMarkers(
         * as dependencies
         */
        deps: depsList,
-        depsLoc,
        loc: fnExpr.loc,
      },
      effects: null,
@@ -293,85 +287,86 @@ function extractManualMemoizationArgs(
  sidemap: IdentifierSidemap,
  errors: CompilerError,
 ): {
-  fnPlace: Place;
+  fnPlace: Place | null;
  depsList: Array<ManualMemoDependency> | null;
-  depsLoc: SourceLocation | null;
-} | null {
+} {
  const [fnPlace, depsListPlace] = instr.value.args as Array<
    Place | SpreadPattern | undefined
  >;
-  if (fnPlace == null || fnPlace.kind !== 'Identifier') {
+  if (fnPlace == null) {
    errors.pushDiagnostic(
      CompilerDiagnostic.create({
        category: ErrorCategory.UseMemo,
        reason: `Expected a callback function to be passed to ${kind}`,
-        description:
-          kind === 'useCallback'
-            ? 'The first argument to useCallback() must be a function to cache'
-            : 'The first argument to useMemo() must be a function that calculates a result to cache',
+        description: `Expected a callback function to be passed to ${kind}`,
        suggestions: null,
      }).withDetails({
        kind: 'error',
        loc: instr.value.loc,
-        message:
-          kind === 'useCallback'
-            ? `Expected a callback function`
-            : `Expected a memoization function`,
+        message: `Expected a callback function to be passed to ${kind}`,
      }),
    );
-    return null;
+    return {fnPlace: null, depsList: null};
  }
-  if (depsListPlace == null) {
-    return {
-      fnPlace,
-      depsList: null,
-      depsLoc: null,
-    };
-  }
-  const maybeDepsList =
-    depsListPlace.kind === 'Identifier'
-      ? sidemap.maybeDepsLists.get(depsListPlace.identifier.id)
-      : null;
-  if (maybeDepsList == null) {
+  if (fnPlace.kind === 'Spread' || depsListPlace?.kind === 'Spread') {
    errors.pushDiagnostic(
      CompilerDiagnostic.create({
        category: ErrorCategory.UseMemo,
-        reason: `Expected the dependency list for ${kind} to be an array literal`,
-        description: `Expected the dependency list for ${kind} to be an array literal`,
+        reason: `Unexpected spread argument to ${kind}`,
+        description: `Unexpected spread argument to ${kind}`,
        suggestions: null,
      }).withDetails({
        kind: 'error',
-        loc:
-          depsListPlace?.kind === 'Identifier' ? depsListPlace.loc : instr.loc,
-        message: `Expected the dependency list for ${kind} to be an array literal`,
+        loc: instr.value.loc,
+        message: `Unexpected spread argument to ${kind}`,
      }),
    );
-    return null;
+    return {fnPlace: null, depsList: null};
  }
-  const depsList: Array<ManualMemoDependency> = [];
-  for (const dep of maybeDepsList.deps) {
-    const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
-    if (maybeDep == null) {
+  let depsList: Array<ManualMemoDependency> | null = null;
+  if (depsListPlace != null) {
+    const maybeDepsList = sidemap.maybeDepsLists.get(
+      depsListPlace.identifier.id,
+    );
+    if (maybeDepsList == null) {
      errors.pushDiagnostic(
        CompilerDiagnostic.create({
          category: ErrorCategory.UseMemo,
-          reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
-          description: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+          reason: `Expected the dependency list for ${kind} to be an array literal`,
+          description: `Expected the dependency list for ${kind} to be an array literal`,
          suggestions: null,
        }).withDetails({
          kind: 'error',
-          loc: dep.loc,
-          message: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+          loc: depsListPlace.loc,
+          message: `Expected the dependency list for ${kind} to be an array literal`,
        }),
      );
-    } else {
-      depsList.push(maybeDep);
+      return {fnPlace, depsList: null};
+    }
+    depsList = [];
+    for (const dep of maybeDepsList) {
+      const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
+      if (maybeDep == null) {
+        errors.pushDiagnostic(
+          CompilerDiagnostic.create({
+            category: ErrorCategory.UseMemo,
+            reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+            description: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+            suggestions: null,
+          }).withDetails({
+            kind: 'error',
+            loc: dep.loc,
+            message: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+          }),
+        );
+      } else {
+        depsList.push(maybeDep);
+      }
    }
  }
  return {
    fnPlace,
    depsList,
-    depsLoc: maybeDepsList.loc,
  };
 }

@@ -432,17 +427,16 @@ export function dropManualMemoization(

        const manualMemo = sidemap.manualMemos.get(id);
        if (manualMemo != null) {
-          const memoDetails = extractManualMemoizationArgs(
+          const {fnPlace, depsList} = extractManualMemoizationArgs(
            instr as TInstruction<CallExpression> | TInstruction<MethodCall>,
            manualMemo.kind,
            sidemap,
            errors,
          );

-          if (memoDetails == null) {
+          if (fnPlace == null) {
            continue;
          }
-          const {fnPlace, depsList, depsLoc} = memoDetails;

          instr.value = getManualMemoizationReplacement(
            fnPlace,
@@ -493,7 +487,6 @@ export function dropManualMemoization(
              fnPlace,
              func.env,
              depsList,
-              depsLoc,
              memoDecl,
              nextManualMemoId++,
            );
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingEffects.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingEffects.ts
@@ -954,7 +954,6 @@ function applyEffect(
        case ValueKind.Primitive: {
          break;
        }
-        case ValueKind.MaybeFrozen:
        case ValueKind.Frozen: {
          sourceType = 'frozen';
          break;
@@ -2452,7 +2451,7 @@ function computeEffectsForLegacySignature(
      }),
    });
  }
-  if (signature.knownIncompatible != null && state.env.enableValidations) {
+  if (signature.knownIncompatible != null && state.env.isInferredMemoEnabled) {
    const errors = new CompilerError();
    errors.pushDiagnostic(
      CompilerDiagnostic.create({
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferReactivePlaces.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferReactivePlaces.ts
@@ -7,6 +7,7 @@

 import {CompilerError} from '..';
 import {
+  BlockId,
  Effect,
  Environment,
  HIRFunction,
@@ -14,12 +15,14 @@ import {
  IdentifierId,
  Instruction,
  Place,
+  computePostDominatorTree,
  evaluatesToStableTypeOrContainer,
  getHookKind,
  isStableType,
  isStableTypeContainer,
  isUseOperator,
 } from '../HIR';
+import {PostDominator} from '../HIR/Dominator';
 import {
  eachInstructionLValue,
  eachInstructionOperand,
@@ -32,7 +35,6 @@ import {
 } from '../ReactiveScopes/InferReactiveScopeVariables';
 import DisjointSet from '../Utils/DisjointSet';
 import {assertExhaustive} from '../Utils/utils';
-import {createControlDominators} from './ControlDominators';

 /**
 * Side map to track and propagate sources of stability (i.e. hook calls such as
@@ -210,9 +212,45 @@ export function inferReactivePlaces(fn: HIRFunction): void {
    reactiveIdentifiers.markReactive(place);
  }

-  const isReactiveControlledBlock = createControlDominators(fn, place =>
-    reactiveIdentifiers.isReactive(place),
-  );
+  const postDominators = computePostDominatorTree(fn, {
+    includeThrowsAsExitNode: false,
+  });
+  const postDominatorFrontierCache = new Map<BlockId, Set<BlockId>>();
+
+  function isReactiveControlledBlock(id: BlockId): boolean {
+    let controlBlocks = postDominatorFrontierCache.get(id);
+    if (controlBlocks === undefined) {
+      controlBlocks = postDominatorFrontier(fn, postDominators, id);
+      postDominatorFrontierCache.set(id, controlBlocks);
+    }
+    for (const blockId of controlBlocks) {
+      const controlBlock = fn.body.blocks.get(blockId)!;
+      switch (controlBlock.terminal.kind) {
+        case 'if':
+        case 'branch': {
+          if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
+            return true;
+          }
+          break;
+        }
+        case 'switch': {
+          if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
+            return true;
+          }
+          for (const case_ of controlBlock.terminal.cases) {
+            if (
+              case_.test !== null &&
+              reactiveIdentifiers.isReactive(case_.test)
+            ) {
+              return true;
+            }
+          }
+          break;
+        }
+      }
+    }
+    return false;
+  }

  do {
    for (const [, block] of fn.body.blocks) {
@@ -373,6 +411,61 @@ export function inferReactivePlaces(fn: HIRFunction): void {
  propagateReactivityToInnerFunctions(fn, true);
 }

+/*
+ * Computes the post-dominator frontier of @param block. These are immediate successors of nodes that
+ * post-dominate @param targetId and from which execution may not reach @param block. Intuitively, these
+ * are the earliest blocks from which execution branches such that it may or may not reach the target block.
+ */
+function postDominatorFrontier(
+  fn: HIRFunction,
+  postDominators: PostDominator<BlockId>,
+  targetId: BlockId,
+): Set<BlockId> {
+  const visited = new Set<BlockId>();
+  const frontier = new Set<BlockId>();
+  const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
+  for (const blockId of [...targetPostDominators, targetId]) {
+    if (visited.has(blockId)) {
+      continue;
+    }
+    visited.add(blockId);
+    const block = fn.body.blocks.get(blockId)!;
+    for (const pred of block.preds) {
+      if (!targetPostDominators.has(pred)) {
+        // The predecessor does not always reach this block, we found an item on the frontier!
+        frontier.add(pred);
+      }
+    }
+  }
+  return frontier;
+}
+
+function postDominatorsOf(
+  fn: HIRFunction,
+  postDominators: PostDominator<BlockId>,
+  targetId: BlockId,
+): Set<BlockId> {
+  const result = new Set<BlockId>();
+  const visited = new Set<BlockId>();
+  const queue = [targetId];
+  while (queue.length) {
+    const currentId = queue.shift()!;
+    if (visited.has(currentId)) {
+      continue;
+    }
+    visited.add(currentId);
+    const current = fn.body.blocks.get(currentId)!;
+    for (const pred of current.preds) {
+      const predPostDominator = postDominators.get(pred) ?? pred;
+      if (predPostDominator === targetId || result.has(predPostDominator)) {
+        result.add(pred);
+      }
+      queue.push(pred);
+    }
+  }
+  return result;
+}
+
 class ReactivityMap {
  hasChanges: boolean = false;
  reactive: Set<IdentifierId> = new Set();
--- a/compiler/packages/babel-plugin-react-compiler/src/Optimization/ConstantPropagation.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Optimization/ConstantPropagation.ts
@@ -609,19 +609,6 @@ function evaluateInstruction(
      constantPropagationImpl(value.loweredFunc.func, constants);
      return null;
    }
-    case 'StartMemoize': {
-      if (value.deps != null) {
-        for (const dep of value.deps) {
-          if (dep.root.kind === 'NamedLocal') {
-            const placeValue = read(constants, dep.root.value);
-            if (placeValue != null && placeValue.kind === 'Primitive') {
-              dep.root.constant = true;
-            }
-          }
-        }
-      }
-      return null;
-    }
    default: {
      // TODO: handle more cases
      return null;
--- a/compiler/packages/babel-plugin-react-compiler/src/Optimization/DeadCodeElimination.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Optimization/DeadCodeElimination.ts
@@ -7,8 +7,6 @@

 import {
  BlockId,
-  Environment,
-  getHookKind,
  HIRFunction,
  Identifier,
  IdentifierId,
@@ -70,14 +68,9 @@ export function deadCodeElimination(fn: HIRFunction): void {
 }

 class State {
-  env: Environment;
  named: Set<string> = new Set();
  identifiers: Set<IdentifierId> = new Set();

-  constructor(env: Environment) {
-    this.env = env;
-  }
-
  // Mark the identifier as being referenced (not dead code)
  reference(identifier: Identifier): void {
    this.identifiers.add(identifier.id);
@@ -119,7 +112,7 @@ function findReferencedIdentifiers(fn: HIRFunction): State {
  const hasLoop = hasBackEdge(fn);
  const reversedBlocks = [...fn.body.blocks.values()].reverse();

-  const state = new State(fn.env);
+  const state = new State();
  let size = state.count;
  do {
    size = state.count;
@@ -317,27 +310,12 @@ function pruneableValue(value: InstructionValue, state: State): boolean {
      // explicitly retain debugger statements to not break debugging workflows
      return false;
    }
-    case 'CallExpression':
-    case 'MethodCall': {
-      if (state.env.outputMode === 'ssr') {
-        const calleee =
-          value.kind === 'CallExpression' ? value.callee : value.property;
-        const hookKind = getHookKind(state.env, calleee.identifier);
-        switch (hookKind) {
-          case 'useState':
-          case 'useReducer':
-          case 'useRef': {
-            // unused refs can be removed
-            return true;
-          }
-        }
-      }
-      return false;
-    }
    case 'Await':
+    case 'CallExpression':
    case 'ComputedDelete':
    case 'ComputedStore':
    case 'PropertyDelete':
+    case 'MethodCall':
    case 'PropertyStore':
    case 'StoreGlobal': {
      /*
--- a/compiler/packages/babel-plugin-react-compiler/src/Optimization/OptimizeForSSR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Optimization/OptimizeForSSR.ts
@@ -1,269 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {CompilerError} from '..';
-import {
-  CallExpression,
-  getHookKind,
-  HIRFunction,
-  IdentifierId,
-  InstructionValue,
-  isArrayType,
-  isPlainObjectType,
-  isPrimitiveType,
-  isSetStateType,
-  isStartTransitionType,
-  LoadLocal,
-  StoreLocal,
-} from '../HIR';
-import {
-  eachInstructionValueOperand,
-  eachTerminalOperand,
-} from '../HIR/visitors';
-import {retainWhere} from '../Utils/utils';
-
-/**
- * Optimizes the code for running specifically in an SSR environment. This optimization
- * asssumes that setState will not be called during render during initial mount, which
- * allows inlining useState/useReducer.
- *
- * Optimizations:
- * - Inline useState/useReducer
- * - Remove effects
- * - Remove refs where known to be unused during render (eg directly passed to a dom node)
- * - Remove event handlers
- *
- * Note that an earlier pass already inlines useMemo/useCallback
- */
-export function optimizeForSSR(fn: HIRFunction): void {
-  const inlinedState = new Map<IdentifierId, InstructionValue>();
-  /**
-   * First pass identifies useState/useReducer which can be safely inlined. Any use
-   * of the hook return other than destructuring (with a specific pattern) prevents
-   * inlining.
-   *
-   * Supported cases:
-   * - `const [state, ] = useState( <primitive-array-or-object> )`
-   * - `const [state, ] = useReducer(..., <value>)`
-   * - `const [state, ] = useReducer[..., <value>, <init>]`
-   */
-  for (const block of fn.body.blocks.values()) {
-    for (const instr of block.instructions) {
-      const {value} = instr;
-      switch (value.kind) {
-        case 'Destructure': {
-          if (
-            inlinedState.has(value.value.identifier.id) &&
-            value.lvalue.pattern.kind === 'ArrayPattern' &&
-            value.lvalue.pattern.items.length >= 1 &&
-            value.lvalue.pattern.items[0].kind === 'Identifier'
-          ) {
-            // Allow destructuring of inlined states
-            continue;
-          }
-          break;
-        }
-        case 'MethodCall':
-        case 'CallExpression': {
-          const calleee =
-            value.kind === 'CallExpression' ? value.callee : value.property;
-          const hookKind = getHookKind(fn.env, calleee.identifier);
-          switch (hookKind) {
-            case 'useReducer': {
-              if (
-                value.args.length === 2 &&
-                value.args[1].kind === 'Identifier'
-              ) {
-                const arg = value.args[1];
-                const replace: LoadLocal = {
-                  kind: 'LoadLocal',
-                  place: arg,
-                  loc: arg.loc,
-                };
-                inlinedState.set(instr.lvalue.identifier.id, replace);
-              } else if (
-                value.args.length === 3 &&
-                value.args[1].kind === 'Identifier' &&
-                value.args[2].kind === 'Identifier'
-              ) {
-                const arg = value.args[1];
-                const initializer = value.args[2];
-                const replace: CallExpression = {
-                  kind: 'CallExpression',
-                  callee: initializer,
-                  args: [arg],
-                  loc: value.loc,
-                };
-                inlinedState.set(instr.lvalue.identifier.id, replace);
-              }
-              break;
-            }
-            case 'useState': {
-              if (
-                value.args.length === 1 &&
-                value.args[0].kind === 'Identifier'
-              ) {
-                const arg = value.args[0];
-                if (
-                  isPrimitiveType(arg.identifier) ||
-                  isPlainObjectType(arg.identifier) ||
-                  isArrayType(arg.identifier)
-                ) {
-                  const replace: LoadLocal = {
-                    kind: 'LoadLocal',
-                    place: arg,
-                    loc: arg.loc,
-                  };
-                  inlinedState.set(instr.lvalue.identifier.id, replace);
-                }
-              }
-              break;
-            }
-          }
-        }
-      }
-      // Any use of useState/useReducer return besides destructuring prevents inlining
-      if (inlinedState.size !== 0) {
-        for (const operand of eachInstructionValueOperand(value)) {
-          inlinedState.delete(operand.identifier.id);
-        }
-      }
-    }
-    if (inlinedState.size !== 0) {
-      for (const operand of eachTerminalOperand(block.terminal)) {
-        inlinedState.delete(operand.identifier.id);
-      }
-    }
-  }
-  for (const block of fn.body.blocks.values()) {
-    for (const instr of block.instructions) {
-      const {value} = instr;
-      switch (value.kind) {
-        case 'FunctionExpression': {
-          if (hasKnownNonRenderCall(value.loweredFunc.func)) {
-            instr.value = {
-              kind: 'Primitive',
-              value: undefined,
-              loc: value.loc,
-            };
-          }
-          break;
-        }
-        case 'JsxExpression': {
-          if (
-            value.tag.kind === 'BuiltinTag' &&
-            value.tag.name.indexOf('-') === -1
-          ) {
-            const tag = value.tag.name;
-            retainWhere(value.props, prop => {
-              return (
-                prop.kind === 'JsxSpreadAttribute' ||
-                (!isKnownEventHandler(tag, prop.name) && prop.name !== 'ref')
-              );
-            });
-          }
-          break;
-        }
-        case 'Destructure': {
-          if (inlinedState.has(value.value.identifier.id)) {
-            // Canonical check is part of determining if state can inline, this is for TS
-            CompilerError.invariant(
-              value.lvalue.pattern.kind === 'ArrayPattern' &&
-                value.lvalue.pattern.items.length >= 1 &&
-                value.lvalue.pattern.items[0].kind === 'Identifier',
-              {
-                reason:
-                  'Expected a valid destructuring pattern for inlined state',
-                description: null,
-                details: [
-                  {
-                    kind: 'error',
-                    message: 'Expected a valid destructuring pattern',
-                    loc: value.loc,
-                  },
-                ],
-              },
-            );
-            const store: StoreLocal = {
-              kind: 'StoreLocal',
-              loc: value.loc,
-              type: null,
-              lvalue: {
-                kind: value.lvalue.kind,
-                place: value.lvalue.pattern.items[0],
-              },
-              value: value.value,
-            };
-            instr.value = store;
-          }
-          break;
-        }
-        case 'MethodCall':
-        case 'CallExpression': {
-          const calleee =
-            value.kind === 'CallExpression' ? value.callee : value.property;
-          const hookKind = getHookKind(fn.env, calleee.identifier);
-          switch (hookKind) {
-            case 'useEffectEvent': {
-              if (
-                value.args.length === 1 &&
-                value.args[0].kind === 'Identifier'
-              ) {
-                const load: LoadLocal = {
-                  kind: 'LoadLocal',
-                  place: value.args[0],
-                  loc: value.loc,
-                };
-                instr.value = load;
-              }
-              break;
-            }
-            case 'useEffect':
-            case 'useLayoutEffect':
-            case 'useInsertionEffect': {
-              // Drop effects
-              instr.value = {
-                kind: 'Primitive',
-                value: undefined,
-                loc: value.loc,
-              };
-              break;
-            }
-            case 'useReducer':
-            case 'useState': {
-              const replace = inlinedState.get(instr.lvalue.identifier.id);
-              if (replace != null) {
-                instr.value = replace;
-              }
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-function hasKnownNonRenderCall(fn: HIRFunction): boolean {
-  for (const block of fn.body.blocks.values()) {
-    for (const instr of block.instructions) {
-      if (
-        instr.value.kind === 'CallExpression' &&
-        (isSetStateType(instr.value.callee.identifier) ||
-          isStartTransitionType(instr.value.callee.identifier))
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-const EVENT_HANDLER_PATTERN = /^on[A-Z]/;
-function isKnownEventHandler(_tag: string, prop: string): boolean {
-  return EVENT_HANDLER_PATTERN.test(prop);
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineJsx.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineJsx.ts
@@ -515,7 +515,6 @@ function emitDestructureProps(
        pattern: {
          kind: 'ObjectPattern',
          properties,
-          loc: GeneratedSource,
        },
        kind: InstructionKind.Let,
      },
--- a/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts
@@ -159,7 +159,7 @@ export function codegenFunction(
  const compiled = compileResult.unwrap();

  const hookGuard = fn.env.config.enableEmitHookGuards;
-  if (hookGuard != null && fn.env.outputMode === 'client') {
+  if (hookGuard != null && fn.env.isInferredMemoEnabled) {
    compiled.body = t.blockStatement([
      createHookGuard(
        hookGuard,
@@ -259,7 +259,7 @@ export function codegenFunction(
  if (
    emitInstrumentForget != null &&
    fn.id != null &&
-    fn.env.outputMode === 'client'
+    fn.env.isInferredMemoEnabled
  ) {
    /*
     * Technically, this is a conditional hook call. However, we expect
@@ -591,10 +591,7 @@ function codegenBlockNoReset(
 }

 function wrapCacheDep(cx: Context, value: t.Expression): t.Expression {
-  if (
-    cx.env.config.enableEmitFreeze != null &&
-    cx.env.outputMode === 'client'
-  ) {
+  if (cx.env.config.enableEmitFreeze != null && cx.env.isInferredMemoEnabled) {
    const emitFreezeIdentifier = cx.env.programContext.addImportSpecifier(
      cx.env.config.enableEmitFreeze,
    ).name;
@@ -702,7 +699,7 @@ function codegenReactiveScope(
    outputComments.push(name.name);
    if (!cx.hasDeclared(identifier)) {
      statements.push(
-        t.variableDeclaration('let', [createVariableDeclarator(name, null)]),
+        t.variableDeclaration('let', [t.variableDeclarator(name)]),
      );
    }
    cacheLoads.push({name, index, value: wrapCacheDep(cx, name)});
@@ -1362,6 +1359,8 @@ function codegenInstructionNullable(
      value = null;
    } else {
      lvalue = instr.value.lvalue.pattern;
+      let hasReassign = false;
+      let hasDeclaration = false;
      for (const place of eachPatternOperand(lvalue)) {
        if (
          kind !== InstructionKind.Reassign &&
@@ -1369,6 +1368,26 @@ function codegenInstructionNullable(
        ) {
          cx.temp.set(place.identifier.declarationId, null);
        }
+        const isDeclared = cx.hasDeclared(place.identifier);
+        hasReassign ||= isDeclared;
+        hasDeclaration ||= !isDeclared;
+      }
+      if (hasReassign && hasDeclaration) {
+        CompilerError.invariant(false, {
+          reason:
+            'Encountered a destructuring operation where some identifiers are already declared (reassignments) but others are not (declarations)',
+          description: null,
+          details: [
+            {
+              kind: 'error',
+              loc: instr.loc,
+              message: null,
+            },
+          ],
+          suggestions: null,
+        });
+      } else if (hasReassign) {
+        kind = InstructionKind.Reassign;
      }
      value = codegenPlaceToExpression(cx, instr.value.value);
    }
@@ -1387,7 +1406,7 @@ function codegenInstructionNullable(
          suggestions: null,
        });
        return createVariableDeclaration(instr.loc, 'const', [
-          createVariableDeclarator(codegenLValue(cx, lvalue), value),
+          t.variableDeclarator(codegenLValue(cx, lvalue), value),
        ]);
      }
      case InstructionKind.Function: {
@@ -1451,7 +1470,7 @@ function codegenInstructionNullable(
          suggestions: null,
        });
        return createVariableDeclaration(instr.loc, 'let', [
-          createVariableDeclarator(codegenLValue(cx, lvalue), value),
+          t.variableDeclarator(codegenLValue(cx, lvalue), value),
        ]);
      }
      case InstructionKind.Reassign: {
@@ -1691,9 +1710,6 @@ function withLoc<T extends (...args: Array<any>) => t.Node>(
  };
 }

-const createIdentifier = withLoc(t.identifier);
-const createArrayPattern = withLoc(t.arrayPattern);
-const createObjectPattern = withLoc(t.objectPattern);
 const createBinaryExpression = withLoc(t.binaryExpression);
 const createExpressionStatement = withLoc(t.expressionStatement);
 const _createLabelledStatement = withLoc(t.labeledStatement);
@@ -1725,31 +1741,6 @@ const createTryStatement = withLoc(t.tryStatement);
 const createBreakStatement = withLoc(t.breakStatement);
 const createContinueStatement = withLoc(t.continueStatement);

-function createVariableDeclarator(
-  id: t.LVal,
-  init?: t.Expression | null,
-): t.VariableDeclarator {
-  const node = t.variableDeclarator(id, init);
-
-  /*
-   * The variable declarator location is not preserved in HIR, however, we can use the
-   * start location of the id and the end location of the init to recreate the
-   * exact original variable declarator location.
-   *
-   * Or if init is null, we likely have a declaration without an initializer, so we can use the id.loc.end as the end location.
-   */
-  if (id.loc && (init === null || init?.loc)) {
-    node.loc = {
-      start: id.loc.start,
-      end: init?.loc?.end ?? id.loc.end,
-      filename: id.loc.filename,
-      identifierName: undefined,
-    };
-  }
-
-  return node;
-}
-
 function createHookGuard(
  guard: ExternalFunction,
  context: ProgramContext,
@@ -1803,7 +1794,7 @@ function createCallExpression(
  }

  const hookGuard = env.config.enableEmitHookGuards;
-  if (hookGuard != null && isHook && env.outputMode === 'client') {
+  if (hookGuard != null && isHook && env.isInferredMemoEnabled) {
    const iife = t.functionExpression(
      null,
      [],
@@ -1857,7 +1848,7 @@ function codegenInstruction(
      );
    } else {
      return createVariableDeclaration(instr.loc, 'const', [
-        createVariableDeclarator(
+        t.variableDeclarator(
          convertIdentifier(instr.lvalue.identifier),
          expressionValue,
        ),
@@ -2784,7 +2775,7 @@ function codegenArrayPattern(
 ): t.ArrayPattern {
  const hasHoles = !pattern.items.every(e => e.kind !== 'Hole');
  if (hasHoles) {
-    const result = createArrayPattern(pattern.loc, []);
+    const result = t.arrayPattern([]);
    /*
     * Older versions of babel have a validation bug fixed by
     * https://github.com/babel/babel/pull/10917
@@ -2805,8 +2796,7 @@ function codegenArrayPattern(
    }
    return result;
  } else {
-    return createArrayPattern(
-      pattern.loc,
+    return t.arrayPattern(
      pattern.items.map(item => {
        if (item.kind === 'Hole') {
          return null;
@@ -2826,8 +2816,7 @@ function codegenLValue(
      return codegenArrayPattern(cx, pattern);
    }
    case 'ObjectPattern': {
-      return createObjectPattern(
-        pattern.loc,
+      return t.objectPattern(
        pattern.properties.map(property => {
          if (property.kind === 'ObjectProperty') {
            const key = codegenObjectPropertyKey(cx, property.key);
@@ -2946,7 +2935,7 @@ function convertIdentifier(identifier: Identifier): t.Identifier {
      suggestions: null,
    },
  );
-  return createIdentifier(identifier.loc, identifier.name.value);
+  return t.identifier(identifier.name.value);
 }

 function compareScopeDependency(
--- a/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts
@@ -19,11 +19,7 @@ import {
  promoteTemporary,
 } from '../HIR';
 import {clonePlaceToTemporary} from '../HIR/HIRBuilder';
-import {
-  eachInstructionLValueWithKind,
-  eachPatternOperand,
-  mapPatternOperands,
-} from '../HIR/visitors';
+import {eachPatternOperand, mapPatternOperands} from '../HIR/visitors';
 import {
  ReactiveFunctionTransform,
  Transformed,
@@ -117,9 +113,6 @@ class Visitor extends ReactiveFunctionTransform<State> {
  ): Transformed<ReactiveStatement> {
    this.visitInstruction(instruction, state);

-    let instructionsToProcess: Array<ReactiveInstruction> = [instruction];
-    let result: Transformed<ReactiveStatement> = {kind: 'keep'};
-
    if (instruction.value.kind === 'Destructure') {
      const transformed = transformDestructuring(
        state,
@@ -127,8 +120,7 @@ class Visitor extends ReactiveFunctionTransform<State> {
        instruction.value,
      );
      if (transformed) {
-        instructionsToProcess = transformed;
-        result = {
+        return {
          kind: 'replace-many',
          value: transformed.map(instruction => ({
            kind: 'instruction',
@@ -137,17 +129,7 @@ class Visitor extends ReactiveFunctionTransform<State> {
        };
      }
    }
-
-    // Update state.declared with declarations from the instruction(s)
-    for (const instr of instructionsToProcess) {
-      for (const [place, kind] of eachInstructionLValueWithKind(instr)) {
-        if (kind !== InstructionKind.Reassign) {
-          state.declared.add(place.identifier.declarationId);
-        }
-      }
-    }
-
-    return result;
+    return {kind: 'keep'};
  }
 }

@@ -162,13 +144,10 @@ function transformDestructuring(
    const isDeclared = state.declared.has(place.identifier.declarationId);
    if (isDeclared) {
      reassigned.add(place.identifier.id);
-    } else {
-      hasDeclaration = true;
    }
+    hasDeclaration ||= !isDeclared;
  }
-  if (!hasDeclaration) {
-    // all reassignments
-    destructure.lvalue.kind = InstructionKind.Reassign;
+  if (reassigned.size === 0 || !hasDeclaration) {
    return null;
  }
  /*
--- a/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/InferReactiveScopeVariables.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/InferReactiveScopeVariables.ts
@@ -389,6 +389,14 @@ export function findDisjointMutableValues(
             */
            operand.identifier.mutableRange.start > 0
          ) {
+            if (
+              instr.value.kind === 'FunctionExpression' ||
+              instr.value.kind === 'ObjectMethod'
+            ) {
+              if (operand.identifier.type.kind === 'Primitive') {
+                continue;
+              }
+            }
            operands.push(operand.identifier);
          }
        }
--- a/compiler/packages/babel-plugin-react-compiler/src/TypeInference/InferTypes.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/TypeInference/InferTypes.ts
@@ -25,7 +25,6 @@ import {
 } from '../HIR/HIR';
 import {
  BuiltInArrayId,
-  BuiltInEventHandlerId,
  BuiltInFunctionId,
  BuiltInJsxId,
  BuiltInMixedReadonlyId,
@@ -472,41 +471,6 @@ function* generateInstructionTypes(
          }
        }
      }
-      if (env.config.enableInferEventHandlers) {
-        if (
-          value.kind === 'JsxExpression' &&
-          value.tag.kind === 'BuiltinTag' &&
-          !value.tag.name.includes('-')
-        ) {
-          /*
-           * Infer event handler types for built-in DOM elements.
-           * Props starting with "on" (e.g., onClick, onSubmit) on primitive tags
-           * are inferred as event handlers. This allows functions with ref access
-           * to be passed to these props, since DOM event handlers are guaranteed
-           * by React to only execute in response to events, never during render.
-           *
-           * We exclude tags with hyphens to avoid web components (custom elements),
-           * which are required by the HTML spec to contain a hyphen. Web components
-           * may call event handler props during their lifecycle methods (e.g.,
-           * connectedCallback), which would be unsafe for ref access.
-           */
-          for (const prop of value.props) {
-            if (
-              prop.kind === 'JsxAttribute' &&
-              prop.name.startsWith('on') &&
-              prop.name.length > 2 &&
-              prop.name[2] === prop.name[2].toUpperCase()
-            ) {
-              yield equation(prop.place.identifier.type, {
-                kind: 'Function',
-                shapeId: BuiltInEventHandlerId,
-                return: makeType(),
-                isConstructor: false,
-              });
-            }
-          }
-        }
-      }
      yield equation(left, {kind: 'Object', shapeId: BuiltInJsxId});
      break;
    }
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts
@@ -5,7 +5,6 @@
 * LICENSE file in the root directory of this source tree.
 */

-import {Result} from '../Utils/Result';
 import {CompilerDiagnostic, CompilerError, Effect} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {
@@ -21,8 +20,8 @@ import {
  isUseStateType,
  BasicBlock,
  isUseRefType,
+  GeneratedSource,
  SourceLocation,
-  ArrayExpression,
 } from '../HIR';
 import {eachInstructionLValue, eachInstructionOperand} from '../HIR/visitors';
 import {isMutable} from '../ReactiveScopes/InferReactiveScopeVariables';
@@ -37,23 +36,15 @@ type DerivationMetadata = {
  isStateSource: boolean;
 };

-type EffectMetadata = {
-  effect: HIRFunction;
-  dependencies: ArrayExpression;
-};
-
 type ValidationContext = {
  readonly functions: Map<IdentifierId, FunctionExpression>;
-  readonly candidateDependencies: Map<IdentifierId, ArrayExpression>;
  readonly errors: CompilerError;
  readonly derivationCache: DerivationCache;
-  readonly effectsCache: Map<IdentifierId, EffectMetadata>;
-  readonly setStateLoads: Map<IdentifierId, IdentifierId | null>;
-  readonly setStateUsages: Map<IdentifierId, Set<SourceLocation>>;
+  readonly effects: Set<HIRFunction>;
+  readonly setStateCache: Map<string | undefined | null, Array<Place>>;
+  readonly effectSetStateCache: Map<string | undefined | null, Array<Place>>;
 };

-const MAX_FIXPOINT_ITERATIONS = 100;
-
 class DerivationCache {
  hasChanges: boolean = false;
  cache: Map<IdentifierId, DerivationMetadata> = new Map();
@@ -182,24 +173,25 @@ function isNamedIdentifier(place: Place): place is Place & {
 */
 export function validateNoDerivedComputationsInEffects_exp(
  fn: HIRFunction,
-): Result<void, CompilerError> {
+): void {
  const functions: Map<IdentifierId, FunctionExpression> = new Map();
-  const candidateDependencies: Map<IdentifierId, ArrayExpression> = new Map();
  const derivationCache = new DerivationCache();
  const errors = new CompilerError();
-  const effectsCache: Map<IdentifierId, EffectMetadata> = new Map();
+  const effects: Set<HIRFunction> = new Set();

-  const setStateLoads: Map<IdentifierId, IdentifierId> = new Map();
-  const setStateUsages: Map<IdentifierId, Set<SourceLocation>> = new Map();
+  const setStateCache: Map<string | undefined | null, Array<Place>> = new Map();
+  const effectSetStateCache: Map<
+    string | undefined | null,
+    Array<Place>
+  > = new Map();

  const context: ValidationContext = {
    functions,
-    candidateDependencies,
    errors,
    derivationCache,
-    effectsCache,
-    setStateLoads,
-    setStateUsages,
+    effects,
+    setStateCache,
+    effectSetStateCache,
  };

  if (fn.fnType === 'Hook') {
@@ -226,7 +218,6 @@ export function validateNoDerivedComputationsInEffects_exp(
  }

  let isFirstPass = true;
-  let iterationCount = 0;
  do {
    context.derivationCache.takeSnapshot();

@@ -239,26 +230,15 @@ export function validateNoDerivedComputationsInEffects_exp(

    context.derivationCache.checkForChanges();
    isFirstPass = false;
-    iterationCount++;
-    CompilerError.invariant(iterationCount < MAX_FIXPOINT_ITERATIONS, {
-      reason:
-        '[ValidateNoDerivedComputationsInEffects] Fixpoint iteration failed to converge.',
-      description: `Fixpoint iteration exceeded ${MAX_FIXPOINT_ITERATIONS} iterations while tracking derivations. This suggests a cyclic dependency in the derivation cache.`,
-      details: [
-        {
-          kind: 'error',
-          loc: fn.loc,
-          message: `Exceeded ${MAX_FIXPOINT_ITERATIONS} iterations in ValidateNoDerivedComputationsInEffects`,
-        },
-      ],
-    });
  } while (context.derivationCache.snapshot());

-  for (const [, effect] of effectsCache) {
-    validateEffect(effect.effect, effect.dependencies, context);
+  for (const effect of effects) {
+    validateEffect(effect, context);
  }

-  return errors.asResult();
+  if (errors.hasAnyErrors()) {
+    throw errors;
+  }
 }

 function recordPhiDerivations(
@@ -302,61 +282,11 @@ function joinValue(
  return 'fromPropsAndState';
 }

-function getRootSetState(
-  key: IdentifierId,
-  loads: Map<IdentifierId, IdentifierId | null>,
-  visited: Set<IdentifierId> = new Set(),
-): IdentifierId | null {
-  if (visited.has(key)) {
-    return null;
-  }
-  visited.add(key);
-
-  const parentId = loads.get(key);
-
-  if (parentId === undefined) {
-    return null;
-  }
-
-  if (parentId === null) {
-    return key;
-  }
-
-  return getRootSetState(parentId, loads, visited);
-}
-
-function maybeRecordSetState(
-  instr: Instruction,
-  loads: Map<IdentifierId, IdentifierId | null>,
-  usages: Map<IdentifierId, Set<SourceLocation>>,
-): void {
-  for (const operand of eachInstructionLValue(instr)) {
-    if (
-      instr.value.kind === 'LoadLocal' &&
-      loads.has(instr.value.place.identifier.id)
-    ) {
-      loads.set(operand.identifier.id, instr.value.place.identifier.id);
-    } else {
-      if (isSetStateType(operand.identifier)) {
-        // this is a root setState
-        loads.set(operand.identifier.id, null);
-      }
-    }
-
-    const rootSetState = getRootSetState(operand.identifier.id, loads);
-    if (rootSetState !== null && usages.get(rootSetState) === undefined) {
-      usages.set(rootSetState, new Set([operand.loc]));
-    }
-  }
-}
-
 function recordInstructionDerivations(
  instr: Instruction,
  context: ValidationContext,
  isFirstPass: boolean,
 ): void {
-  maybeRecordSetState(instr, context.setStateLoads, context.setStateUsages);
-
  let typeOfValue: TypeOfValue = 'ignored';
  let isSource: boolean = false;
  const sources: Set<IdentifierId> = new Set();
@@ -379,37 +309,25 @@ function recordInstructionDerivations(
      value.args[1].kind === 'Identifier'
    ) {
      const effectFunction = context.functions.get(value.args[0].identifier.id);
-      const deps = context.candidateDependencies.get(
-        value.args[1].identifier.id,
-      );
-      if (effectFunction != null && deps != null) {
-        context.effectsCache.set(value.args[0].identifier.id, {
-          effect: effectFunction.loweredFunc.func,
-          dependencies: deps,
-        });
+      if (effectFunction != null) {
+        context.effects.add(effectFunction.loweredFunc.func);
      }
-    } else if (isUseStateType(lvalue.identifier)) {
-      typeOfValue = 'fromState';
-      context.derivationCache.addDerivationEntry(
-        lvalue,
-        new Set(),
-        typeOfValue,
-        true,
-      );
-      return;
+    } else if (isUseStateType(lvalue.identifier) && value.args.length > 0) {
+      isSource = true;
+      typeOfValue = joinValue(typeOfValue, 'fromState');
    }
-  } else if (value.kind === 'ArrayExpression') {
-    context.candidateDependencies.set(lvalue.identifier.id, value);
  }

  for (const operand of eachInstructionOperand(instr)) {
-    if (context.setStateLoads.has(operand.identifier.id)) {
-      const rootSetStateId = getRootSetState(
-        operand.identifier.id,
-        context.setStateLoads,
-      );
-      if (rootSetStateId !== null) {
-        context.setStateUsages.get(rootSetStateId)?.add(operand.loc);
+    if (
+      isSetStateType(operand.identifier) &&
+      operand.loc !== GeneratedSource &&
+      isFirstPass
+    ) {
+      if (context.setStateCache.has(operand.loc.identifierName)) {
+        context.setStateCache.get(operand.loc.identifierName)!.push(operand);
+      } else {
+        context.setStateCache.set(operand.loc.identifierName, [operand]);
      }
    }

@@ -438,14 +356,6 @@ function recordInstructionDerivations(
    );
  }

-  if (value.kind === 'FunctionExpression') {
-    /*
-     * We don't want to record effect mutations of FunctionExpressions the mutations will happen in the
-     * function body and we will record them there.
-     */
-    return;
-  }
-
  for (const operand of eachInstructionOperand(instr)) {
    switch (operand.effect) {
      case Effect.Capture:
@@ -536,19 +446,6 @@ function buildTreeNode(

  const namedSiblings: Set<string> = new Set();
  for (const childId of sourceMetadata.sourcesIds) {
-    CompilerError.invariant(childId !== sourceId, {
-      reason:
-        'Unexpected self-reference: a value should not have itself as a source',
-      description: null,
-      details: [
-        {
-          kind: 'error',
-          loc: sourceMetadata.place.loc,
-          message: null,
-        },
-      ],
-    });
-
    const childNodes = buildTreeNode(
      childId,
      context,
@@ -628,72 +525,21 @@ function renderTree(
  return result;
 }

-function getFnLocalDeps(
-  fn: FunctionExpression | undefined,
-): Set<IdentifierId> | undefined {
-  if (!fn) {
-    return undefined;
-  }
-
-  const deps: Set<IdentifierId> = new Set();
-
-  for (const [, block] of fn.loweredFunc.func.body.blocks) {
-    for (const instr of block.instructions) {
-      if (instr.value.kind === 'LoadLocal') {
-        deps.add(instr.value.place.identifier.id);
-      }
-    }
-  }
-
-  return deps;
-}
-
 function validateEffect(
  effectFunction: HIRFunction,
-  dependencies: ArrayExpression,
  context: ValidationContext,
 ): void {
  const seenBlocks: Set<BlockId> = new Set();

  const effectDerivedSetStateCalls: Array<{
    value: CallExpression;
-    id: IdentifierId;
+    loc: SourceLocation;
    sourceIds: Set<IdentifierId>;
    typeOfValue: TypeOfValue;
  }> = [];

-  const effectSetStateUsages: Map<
-    IdentifierId,
-    Set<SourceLocation>
-  > = new Map();
-
-  // Consider setStates in the effect's dependency array as being part of effectSetStateUsages
-  for (const dep of dependencies.elements) {
-    if (dep.kind === 'Identifier') {
-      const root = getRootSetState(dep.identifier.id, context.setStateLoads);
-      if (root !== null) {
-        effectSetStateUsages.set(root, new Set([dep.loc]));
-      }
-    }
-  }
-
-  let cleanUpFunctionDeps: Set<IdentifierId> | undefined;
-
  const globals: Set<IdentifierId> = new Set();
  for (const block of effectFunction.body.blocks.values()) {
-    /*
-     * if the block is in an effect and is of type return then its an effect's cleanup function
-     * if the cleanup function depends on a value from which effect-set state is derived then
-     * we can't validate
-     */
-    if (
-      block.terminal.kind === 'return' &&
-      block.terminal.returnVariant === 'Explicit'
-    ) {
-      cleanUpFunctionDeps = getFnLocalDeps(
-        context.functions.get(block.terminal.value.identifier.id),
-      );
-    }
    for (const pred of block.preds) {
      if (!seenBlocks.has(pred)) {
        // skip if block has a back edge
@@ -707,16 +553,19 @@ function validateEffect(
        return;
      }

-      maybeRecordSetState(instr, context.setStateLoads, effectSetStateUsages);
-
      for (const operand of eachInstructionOperand(instr)) {
-        if (context.setStateLoads.has(operand.identifier.id)) {
-          const rootSetStateId = getRootSetState(
-            operand.identifier.id,
-            context.setStateLoads,
-          );
-          if (rootSetStateId !== null) {
-            effectSetStateUsages.get(rootSetStateId)?.add(operand.loc);
+        if (
+          isSetStateType(operand.identifier) &&
+          operand.loc !== GeneratedSource
+        ) {
+          if (context.effectSetStateCache.has(operand.loc.identifierName)) {
+            context.effectSetStateCache
+              .get(operand.loc.identifierName)!
+              .push(operand);
+          } else {
+            context.effectSetStateCache.set(operand.loc.identifierName, [
+              operand,
+            ]);
          }
        }
      }
@@ -727,18 +576,6 @@ function validateEffect(
        instr.value.args.length === 1 &&
        instr.value.args[0].kind === 'Identifier'
      ) {
-        const calleeMetadata = context.derivationCache.cache.get(
-          instr.value.callee.identifier.id,
-        );
-
-        /*
-         * If the setState comes from a source other than local state skip
-         * since the fix is not to calculate in render
-         */
-        if (calleeMetadata?.typeOfValue != 'fromState') {
-          continue;
-        }
-
        const argMetadata = context.derivationCache.cache.get(
          instr.value.args[0].identifier.id,
        );
@@ -746,7 +583,7 @@ function validateEffect(
        if (argMetadata !== undefined) {
          effectDerivedSetStateCalls.push({
            value: instr.value,
-            id: instr.value.callee.identifier.id,
+            loc: instr.value.callee.loc,
            sourceIds: argMetadata.sourcesIds,
            typeOfValue: argMetadata.typeOfValue,
          });
@@ -780,17 +617,15 @@ function validateEffect(
  }

  for (const derivedSetStateCall of effectDerivedSetStateCalls) {
-    const rootSetStateCall = getRootSetState(
-      derivedSetStateCall.id,
-      context.setStateLoads,
-    );
-
    if (
-      rootSetStateCall !== null &&
-      effectSetStateUsages.has(rootSetStateCall) &&
-      context.setStateUsages.has(rootSetStateCall) &&
-      effectSetStateUsages.get(rootSetStateCall)!.size ===
-        context.setStateUsages.get(rootSetStateCall)!.size - 1
+      derivedSetStateCall.loc !== GeneratedSource &&
+      context.effectSetStateCache.has(derivedSetStateCall.loc.identifierName) &&
+      context.setStateCache.has(derivedSetStateCall.loc.identifierName) &&
+      context.effectSetStateCache.get(derivedSetStateCall.loc.identifierName)!
+        .length ===
+        context.setStateCache.get(derivedSetStateCall.loc.identifierName)!
+          .length -
+          1
    ) {
      const propsSet = new Set<string>();
      const stateSet = new Set<string>();
@@ -816,12 +651,6 @@ function validateEffect(
        ),
      );

-      for (const dep of derivedSetStateCall.sourceIds) {
-        if (cleanUpFunctionDeps !== undefined && cleanUpFunctionDeps.has(dep)) {
-          return;
-        }
-      }
-
      const propsArr = Array.from(propsSet);
      const stateArr = Array.from(stateSet);

--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts
@@ -14,14 +14,12 @@ import {
  BlockId,
  HIRFunction,
  IdentifierId,
-  Identifier,
  Place,
  SourceLocation,
  getHookKindForType,
  isRefValueType,
  isUseRefType,
 } from '../HIR';
-import {BuiltInEventHandlerId} from '../HIR/ObjectShape';
 import {
  eachInstructionOperand,
  eachInstructionValueOperand,
@@ -185,11 +183,6 @@ function refTypeOfType(place: Place): RefAccessType {
  }
 }

-function isEventHandlerType(identifier: Identifier): boolean {
-  const type = identifier.type;
-  return type.kind === 'Function' && type.shapeId === BuiltInEventHandlerId;
-}
-
 function tyEqual(a: RefAccessType, b: RefAccessType): boolean {
  if (a.kind !== b.kind) {
    return false;
@@ -526,9 +519,6 @@ function validateNoRefAccessInRenderImpl(
             */
            if (!didError) {
              const isRefLValue = isUseRefType(instr.lvalue.identifier);
-              const isEventHandlerLValue = isEventHandlerType(
-                instr.lvalue.identifier,
-              );
              for (const operand of eachInstructionValueOperand(instr.value)) {
                /**
                 * By default we check that function call operands are not refs,
@@ -536,16 +526,29 @@ function validateNoRefAccessInRenderImpl(
                 */
                if (
                  isRefLValue ||
-                  isEventHandlerLValue ||
                  (hookKind != null &&
                    hookKind !== 'useState' &&
                    hookKind !== 'useReducer')
                ) {
                  /**
-                   * Allow passing refs or ref-accessing functions when:
-                   * 1. lvalue is a ref (mergeRefs pattern: `mergeRefs(ref1, ref2)`)
-                   * 2. lvalue is an event handler (DOM events execute outside render)
-                   * 3. calling hooks (independently validated for ref safety)
+                   * Special cases:
+                   *
+                   * 1. the lvalue is a ref
+                   * In general passing a ref to a function may access that ref
+                   * value during render, so we disallow it.
+                   *
+                   * The main exception is the "mergeRefs" pattern, ie a function
+                   * that accepts multiple refs as arguments (or an array of refs)
+                   * and returns a new, aggregated ref. If the lvalue is a ref,
+                   * we assume that the user is doing this pattern and allow passing
+                   * refs.
+                   *
+                   * Eg `const mergedRef = mergeRefs(ref1, ref2)`
+                   *
+                   * 2. calling hooks
+                   *
+                   * Hooks are independently checked to ensure they don't access refs
+                   * during render.
                   */
                  validateNoDirectRefValueAccess(errors, operand, env);
                } else if (interpolatedAsJsx.has(instr.lvalue.identifier.id)) {
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInEffects.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInEffects.ts
@@ -16,23 +16,18 @@ import {
  IdentifierId,
  isSetStateType,
  isUseEffectHookType,
-  isUseEffectEventType,
  isUseInsertionEffectHookType,
  isUseLayoutEffectHookType,
  isUseRefType,
  isRefValueType,
  Place,
-  Effect,
-  BlockId,
 } from '../HIR';
 import {
  eachInstructionLValue,
  eachInstructionValueOperand,
 } from '../HIR/visitors';
-import {createControlDominators} from '../Inference/ControlDominators';
-import {isMutable} from '../ReactiveScopes/InferReactiveScopeVariables';
 import {Result} from '../Utils/Result';
-import {assertExhaustive, Iterable_some} from '../Utils/utils';
+import {Iterable_some} from '../Utils/utils';

 /**
 * Validates against calling setState in the body of an effect (useEffect and friends),
@@ -99,20 +94,7 @@ export function validateNoSetStateInEffects(
            instr.value.kind === 'MethodCall'
              ? instr.value.receiver
              : instr.value.callee;
-
-          if (isUseEffectEventType(callee.identifier)) {
-            const arg = instr.value.args[0];
-            if (arg !== undefined && arg.kind === 'Identifier') {
-              const setState = setStateFunctions.get(arg.identifier.id);
-              if (setState !== undefined) {
-                /**
-                 * This effect event function calls setState synchonously,
-                 * treat it as a setState function for transitive tracking
-                 */
-                setStateFunctions.set(instr.lvalue.identifier.id, setState);
-              }
-            }
-          } else if (
+          if (
            isUseEffectHookType(callee.identifier) ||
            isUseLayoutEffectHookType(callee.identifier) ||
            isUseInsertionEffectHookType(callee.identifier)
@@ -121,58 +103,26 @@ export function validateNoSetStateInEffects(
            if (arg !== undefined && arg.kind === 'Identifier') {
              const setState = setStateFunctions.get(arg.identifier.id);
              if (setState !== undefined) {
-                const enableVerbose =
-                  env.config.enableVerboseNoSetStateInEffect;
-                if (enableVerbose) {
-                  errors.pushDiagnostic(
-                    CompilerDiagnostic.create({
-                      category: ErrorCategory.EffectSetState,
-                      reason:
-                        'Calling setState synchronously within an effect can trigger cascading renders',
-                      description:
-                        'Effects are intended to synchronize state between React and external systems. ' +
-                        'Calling setState synchronously causes cascading renders that hurt performance.\n\n' +
-                        'This pattern may indicate one of several issues:\n\n' +
-                        '**1. Non-local derived data**: If the value being set could be computed from props/state ' +
-                        'but requires data from a parent component, consider restructuring state ownership so the ' +
-                        'derivation can happen during render in the component that owns the relevant state.\n\n' +
-                        "**2. Derived event pattern**: If you're detecting when a prop changes (e.g., `isPlaying` " +
-                        'transitioning from false to true), this often indicates the parent should provide an event ' +
-                        'callback (like `onPlay`) instead of just the current state. Request access to the original event.\n\n' +
-                        "**3. Force update / external sync**: If you're forcing a re-render to sync with an external " +
-                        'data source (mutable values outside React), use `useSyncExternalStore` to properly subscribe ' +
-                        'to external state changes.\n\n' +
-                        'See: https://react.dev/learn/you-might-not-need-an-effect',
-                      suggestions: null,
-                    }).withDetails({
-                      kind: 'error',
-                      loc: setState.loc,
-                      message:
-                        'Avoid calling setState() directly within an effect',
-                    }),
-                  );
-                } else {
-                  errors.pushDiagnostic(
-                    CompilerDiagnostic.create({
-                      category: ErrorCategory.EffectSetState,
-                      reason:
-                        'Calling setState synchronously within an effect can trigger cascading renders',
-                      description:
-                        'Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. ' +
-                        'In general, the body of an effect should do one or both of the following:\n' +
-                        '* Update external systems with the latest state from React.\n' +
-                        '* Subscribe for updates from some external system, calling setState in a callback function when external state changes.\n\n' +
-                        'Calling setState synchronously within an effect body causes cascading renders that can hurt performance, and is not recommended. ' +
-                        '(https://react.dev/learn/you-might-not-need-an-effect)',
-                      suggestions: null,
-                    }).withDetails({
-                      kind: 'error',
-                      loc: setState.loc,
-                      message:
-                        'Avoid calling setState() directly within an effect',
-                    }),
-                  );
-                }
+                errors.pushDiagnostic(
+                  CompilerDiagnostic.create({
+                    category: ErrorCategory.EffectSetState,
+                    reason:
+                      'Calling setState synchronously within an effect can trigger cascading renders',
+                    description:
+                      'Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. ' +
+                      'In general, the body of an effect should do one or both of the following:\n' +
+                      '* Update external systems with the latest state from React.\n' +
+                      '* Subscribe for updates from some external system, calling setState in a callback function when external state changes.\n\n' +
+                      'Calling setState synchronously within an effect body causes cascading renders that can hurt performance, and is not recommended. ' +
+                      '(https://react.dev/learn/you-might-not-need-an-effect)',
+                    suggestions: null,
+                  }).withDetails({
+                    kind: 'error',
+                    loc: setState.loc,
+                    message:
+                      'Avoid calling setState() directly within an effect',
+                  }),
+                );
              }
            }
          }
@@ -190,8 +140,6 @@ function getSetStateCall(
  setStateFunctions: Map<IdentifierId, Place>,
  env: Environment,
 ): Place | null {
-  const enableAllowSetStateFromRefsInEffects =
-    env.config.enableAllowSetStateFromRefsInEffects;
  const refDerivedValues: Set<IdentifierId> = new Set();

  const isDerivedFromRef = (place: Place): boolean => {
@@ -202,38 +150,9 @@ function getSetStateCall(
    );
  };

-  const isRefControlledBlock: (id: BlockId) => boolean =
-    enableAllowSetStateFromRefsInEffects
-      ? createControlDominators(fn, place => isDerivedFromRef(place))
-      : (): boolean => false;
-
  for (const [, block] of fn.body.blocks) {
-    if (enableAllowSetStateFromRefsInEffects) {
-      for (const phi of block.phis) {
-        if (isDerivedFromRef(phi.place)) {
-          continue;
-        }
-        let isPhiDerivedFromRef = false;
-        for (const [, operand] of phi.operands) {
-          if (isDerivedFromRef(operand)) {
-            isPhiDerivedFromRef = true;
-            break;
-          }
-        }
-        if (isPhiDerivedFromRef) {
-          refDerivedValues.add(phi.place.identifier.id);
-        } else {
-          for (const [pred] of phi.operands) {
-            if (isRefControlledBlock(pred)) {
-              refDerivedValues.add(phi.place.identifier.id);
-              break;
-            }
-          }
-        }
-      }
-    }
    for (const instr of block.instructions) {
-      if (enableAllowSetStateFromRefsInEffects) {
+      if (env.config.enableAllowSetStateFromRefsInEffects) {
        const hasRefOperand = Iterable_some(
          eachInstructionValueOperand(instr.value),
          isDerivedFromRef,
@@ -243,46 +162,6 @@ function getSetStateCall(
          for (const lvalue of eachInstructionLValue(instr)) {
            refDerivedValues.add(lvalue.identifier.id);
          }
-          // Ref-derived values can also propagate through mutation
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            switch (operand.effect) {
-              case Effect.Capture:
-              case Effect.Store:
-              case Effect.ConditionallyMutate:
-              case Effect.ConditionallyMutateIterator:
-              case Effect.Mutate: {
-                if (isMutable(instr, operand)) {
-                  refDerivedValues.add(operand.identifier.id);
-                }
-                break;
-              }
-              case Effect.Freeze:
-              case Effect.Read: {
-                // no-op
-                break;
-              }
-              case Effect.Unknown: {
-                CompilerError.invariant(false, {
-                  reason: 'Unexpected unknown effect',
-                  description: null,
-                  details: [
-                    {
-                      kind: 'error',
-                      loc: operand.loc,
-                      message: null,
-                    },
-                  ],
-                  suggestions: null,
-                });
-              }
-              default: {
-                assertExhaustive(
-                  operand.effect,
-                  `Unexpected effect kind \`${operand.effect}\``,
-                );
-              }
-            }
-          }
        }

        if (
@@ -324,7 +203,7 @@ function getSetStateCall(
            isSetStateType(callee.identifier) ||
            setStateFunctions.has(callee.identifier.id)
          ) {
-            if (enableAllowSetStateFromRefsInEffects) {
+            if (env.config.enableAllowSetStateFromRefsInEffects) {
              const arg = instr.value.args.at(0);
              if (
                arg !== undefined &&
@@ -337,8 +216,6 @@ function getSetStateCall(
                 * be needed when initial layout measurements from refs need to be stored in state.
                 */
                return null;
-              } else if (isRefControlledBlock(block.id)) {
-                continue;
              }
            }
            /*
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInRender.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInRender.ts
@@ -155,40 +155,20 @@ function validateNoSetStateInRenderImpl(
                }),
              );
            } else if (unconditionalBlocks.has(block.id)) {
-              const enableUseKeyedState = fn.env.config.enableUseKeyedState;
-              if (enableUseKeyedState) {
-                errors.pushDiagnostic(
-                  CompilerDiagnostic.create({
-                    category: ErrorCategory.RenderSetState,
-                    reason: 'Cannot call setState during render',
-                    description:
-                      'Calling setState during render may trigger an infinite loop.\n' +
-                      '* To reset state when other state/props change, use `const [state, setState] = useKeyedState(initialState, key)` to reset `state` when `key` changes.\n' +
-                      '* To derive data from other state/props, compute the derived data during render without using state',
-                    suggestions: null,
-                  }).withDetails({
-                    kind: 'error',
-                    loc: callee.loc,
-                    message: 'Found setState() in render',
-                  }),
-                );
-              } else {
-                errors.pushDiagnostic(
-                  CompilerDiagnostic.create({
-                    category: ErrorCategory.RenderSetState,
-                    reason: 'Cannot call setState during render',
-                    description:
-                      'Calling setState during render may trigger an infinite loop.\n' +
-                      '* To reset state when other state/props change, store the previous value in state and update conditionally: https://react.dev/reference/react/useState#storing-information-from-previous-renders\n' +
-                      '* To derive data from other state/props, compute the derived data during render without using state',
-                    suggestions: null,
-                  }).withDetails({
-                    kind: 'error',
-                    loc: callee.loc,
-                    message: 'Found setState() in render',
-                  }),
-                );
-              }
+              errors.pushDiagnostic(
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.RenderSetState,
+                  reason:
+                    'Calling setState during render may trigger an infinite loop',
+                  description:
+                    'Calling setState during render will trigger another render, and can lead to infinite loops. (https://react.dev/reference/react/useState)',
+                  suggestions: null,
+                }).withDetails({
+                  kind: 'error',
+                  loc: callee.loc,
+                  message: 'Found setState() in render',
+                }),
+              );
            }
          }
          break;
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidatePreservedManualMemoization.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidatePreservedManualMemoization.ts
@@ -242,7 +242,6 @@ function validateInferredDep(
    normalizedDep = {
      root: maybeNormalizedRoot.root,
      path: [...maybeNormalizedRoot.path, ...dep.path],
-      loc: maybeNormalizedRoot.loc,
    };
  } else {
    CompilerError.invariant(dep.identifier.name?.kind === 'named', {
@@ -268,10 +267,8 @@ function validateInferredDep(
          effect: Effect.Read,
          reactive: false,
        },
-        constant: false,
      },
      path: [...dep.path],
-      loc: GeneratedSource,
    };
  }
  for (const decl of declsWithinMemoBlock) {
@@ -382,10 +379,8 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
                root: {
                  kind: 'NamedLocal',
                  value: storeTarget,
-                  constant: false,
                },
                path: [],
-                loc: storeTarget.loc,
              });
            }
          }
@@ -413,10 +408,8 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
        root: {
          kind: 'NamedLocal',
          value: {...lvalue},
-          constant: false,
        },
        path: [],
-        loc: lvalue.loc,
      });
    }
  }
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateSourceLocations.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateSourceLocations.ts
@@ -1,296 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {NodePath} from '@babel/traverse';
-import * as t from '@babel/types';
-import {CompilerDiagnostic, CompilerError, ErrorCategory} from '..';
-import {CodegenFunction} from '../ReactiveScopes';
-import {Result} from '../Utils/Result';
-
-/**
- * IMPORTANT: This validation is only intended for use in unit tests.
- * It is not intended for use in production.
- *
- * This validation is used to ensure that the generated AST has proper source locations
- * for "important" original nodes.
- *
- * There's one big gotcha with this validation: it only works if the "important" original nodes
- * are not optimized away by the compiler.
- *
- * When that scenario happens, we should just update the fixture to not include a node that has no
- * corresponding node in the generated AST due to being completely removed during compilation.
- */
-
-/**
- * Some common node types that are important for coverage tracking.
- * Based on istanbul-lib-instrument + some other common nodes we expect to be present in the generated AST.
- *
- * Note: For VariableDeclaration, VariableDeclarator, and Identifier, we enforce stricter validation
- * that requires both the source location AND node type to match in the generated AST. This ensures
- * that variable declarations maintain their structural integrity through compilation.
- */
-const IMPORTANT_INSTRUMENTED_TYPES = new Set([
-  'ArrowFunctionExpression',
-  'AssignmentPattern',
-  'ObjectMethod',
-  'ExpressionStatement',
-  'BreakStatement',
-  'ContinueStatement',
-  'ReturnStatement',
-  'ThrowStatement',
-  'TryStatement',
-  'VariableDeclarator',
-  'IfStatement',
-  'ForStatement',
-  'ForInStatement',
-  'ForOfStatement',
-  'WhileStatement',
-  'DoWhileStatement',
-  'SwitchStatement',
-  'SwitchCase',
-  'WithStatement',
-  'FunctionDeclaration',
-  'FunctionExpression',
-  'LabeledStatement',
-  'ConditionalExpression',
-  'LogicalExpression',
-
-  /**
-   * Note: these aren't important for coverage tracking,
-   * but we still want to track them to ensure we aren't regressing them when
-   * we fix the source location tracking for other nodes.
-   */
-  'VariableDeclaration',
-  'Identifier',
-]);
-
-/**
- * Check if a node is a manual memoization call that the compiler optimizes away.
- * These include useMemo and useCallback calls, which are intentionally removed
- * by the DropManualMemoization pass.
- */
-function isManualMemoization(node: t.Node): boolean {
-  // Check if this is a useMemo/useCallback call expression
-  if (t.isCallExpression(node)) {
-    const callee = node.callee;
-    if (t.isIdentifier(callee)) {
-      return callee.name === 'useMemo' || callee.name === 'useCallback';
-    }
-    if (
-      t.isMemberExpression(callee) &&
-      t.isIdentifier(callee.property) &&
-      t.isIdentifier(callee.object)
-    ) {
-      return (
-        callee.object.name === 'React' &&
-        (callee.property.name === 'useMemo' ||
-          callee.property.name === 'useCallback')
-      );
-    }
-  }
-
-  return false;
-}
-
-/**
- * Create a location key for comparison. We compare by line/column/source,
- * not by object identity.
- */
-function locationKey(loc: t.SourceLocation): string {
-  return `${loc.start.line}:${loc.start.column}-${loc.end.line}:${loc.end.column}`;
-}
-
-/**
- * Validates that important source locations from the original code are preserved
- * in the generated AST. This ensures that Istanbul coverage instrumentation can
- * properly map back to the original source code.
- *
- * The validator:
- * 1. Collects locations from "important" nodes in the original AST (those that
- *    Istanbul instruments for coverage tracking)
- * 2. Exempts known compiler optimizations (useMemo/useCallback removal)
- * 3. Verifies that all important locations appear somewhere in the generated AST
- *
- * Missing locations can cause Istanbul to fail to track coverage for certain
- * code paths, leading to inaccurate coverage reports.
- */
-export function validateSourceLocations(
-  func: NodePath<
-    t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
-  >,
-  generatedAst: CodegenFunction,
-): Result<void, CompilerError> {
-  const errors = new CompilerError();
-
-  /*
-   * Step 1: Collect important locations from the original source
-   * Note: Multiple node types can share the same location (e.g. VariableDeclarator and Identifier)
-   */
-  const importantOriginalLocations = new Map<
-    string,
-    {loc: t.SourceLocation; nodeTypes: Set<string>}
-  >();
-
-  func.traverse({
-    enter(path) {
-      const node = path.node;
-
-      // Only track node types that Istanbul instruments
-      if (!IMPORTANT_INSTRUMENTED_TYPES.has(node.type)) {
-        return;
-      }
-
-      // Skip manual memoization that the compiler intentionally removes
-      if (isManualMemoization(node)) {
-        return;
-      }
-
-      // Collect the location if it exists
-      if (node.loc) {
-        const key = locationKey(node.loc);
-        const existing = importantOriginalLocations.get(key);
-        if (existing) {
-          existing.nodeTypes.add(node.type);
-        } else {
-          importantOriginalLocations.set(key, {
-            loc: node.loc,
-            nodeTypes: new Set([node.type]),
-          });
-        }
-      }
-    },
-  });
-
-  // Step 2: Collect all locations from the generated AST with their node types
-  const generatedLocations = new Map<string, Set<string>>();
-
-  function collectGeneratedLocations(node: t.Node): void {
-    if (node.loc) {
-      const key = locationKey(node.loc);
-      const nodeTypes = generatedLocations.get(key);
-      if (nodeTypes) {
-        nodeTypes.add(node.type);
-      } else {
-        generatedLocations.set(key, new Set([node.type]));
-      }
-    }
-
-    // Use Babel's VISITOR_KEYS to traverse only actual node properties
-    const keys = t.VISITOR_KEYS[node.type as keyof typeof t.VISITOR_KEYS];
-
-    if (!keys) {
-      return;
-    }
-
-    for (const key of keys) {
-      const value = (node as any)[key];
-
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (t.isNode(item)) {
-            collectGeneratedLocations(item);
-          }
-        }
-      } else if (t.isNode(value)) {
-        collectGeneratedLocations(value);
-      }
-    }
-  }
-
-  // Collect from main function body
-  collectGeneratedLocations(generatedAst.body);
-
-  // Collect from outlined functions
-  for (const outlined of generatedAst.outlined) {
-    collectGeneratedLocations(outlined.fn.body);
-  }
-
-  /*
-   * Step 3: Validate that all important locations are preserved
-   * For certain node types, also validate that the node type matches
-   */
-  const strictNodeTypes = new Set([
-    'VariableDeclaration',
-    'VariableDeclarator',
-    'Identifier',
-  ]);
-
-  const reportMissingLocation = (
-    loc: t.SourceLocation,
-    nodeType: string,
-  ): void => {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        category: ErrorCategory.Todo,
-        reason: 'Important source location missing in generated code',
-        description:
-          `Source location for ${nodeType} is missing in the generated output. This can cause coverage instrumentation ` +
-          `to fail to track this code properly, resulting in inaccurate coverage reports.`,
-      }).withDetails({
-        kind: 'error',
-        loc,
-        message: null,
-      }),
-    );
-  };
-
-  const reportWrongNodeType = (
-    loc: t.SourceLocation,
-    expectedType: string,
-    actualTypes: Set<string>,
-  ): void => {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        category: ErrorCategory.Todo,
-        reason:
-          'Important source location has wrong node type in generated code',
-        description:
-          `Source location for ${expectedType} exists in the generated output but with wrong node type(s): ${Array.from(actualTypes).join(', ')}. ` +
-          `This can cause coverage instrumentation to fail to track this code properly, resulting in inaccurate coverage reports.`,
-      }).withDetails({
-        kind: 'error',
-        loc,
-        message: null,
-      }),
-    );
-  };
-
-  for (const [key, {loc, nodeTypes}] of importantOriginalLocations) {
-    const generatedNodeTypes = generatedLocations.get(key);
-
-    if (!generatedNodeTypes) {
-      // Location is completely missing
-      reportMissingLocation(loc, Array.from(nodeTypes).join(', '));
-    } else {
-      // Location exists, check each node type
-      for (const nodeType of nodeTypes) {
-        if (
-          strictNodeTypes.has(nodeType) &&
-          !generatedNodeTypes.has(nodeType)
-        ) {
-          /*
-           * For strict node types, the specific node type must be present
-           * Check if any generated node type is also an important original node type
-           */
-          const hasValidNodeType = Array.from(generatedNodeTypes).some(
-            genType => nodeTypes.has(genType),
-          );
-
-          if (hasValidNodeType) {
-            // At least one generated node type is valid (also in original), so this is just missing
-            reportMissingLocation(loc, nodeType);
-          } else {
-            // None of the generated node types are in original - this is wrong node type
-            reportWrongNodeType(loc, nodeType, generatedNodeTypes);
-          }
-        }
-      }
-    }
-  }
-
-  return errors.asResult();
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Validation/index.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Validation/index.ts
@@ -12,5 +12,4 @@ export {validateNoCapitalizedCalls} from './ValidateNoCapitalizedCalls';
 export {validateNoRefAccessInRender} from './ValidateNoRefAccessInRender';
 export {validateNoSetStateInRender} from './ValidateNoSetStateInRender';
 export {validatePreservedManualMemoization} from './ValidatePreservedManualMemoization';
-export {validateSourceLocations} from './ValidateSourceLocations';
 export {validateUseMemo} from './ValidateUseMemo';
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/alias-capture-in-method-receiver-and-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/alias-capture-in-method-receiver-and-mutate.expect.md
@@ -35,8 +35,10 @@ function Component() {
  let t0;
  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
    const a = makeObject_Primitives();
+
    const x = [];
    x.push(a);
+
    mutate(x);
    t0 = [x, a];
    $[0] = t0;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/alias-capture-in-method-receiver.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/alias-capture-in-method-receiver.expect.md
@@ -33,6 +33,7 @@ function Component() {
  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
    const x = [];
    x.push(a);
+
    t1 = [x, a];
    $[1] = t1;
  } else {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/aliased-nested-scope-fn-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/aliased-nested-scope-fn-expr.expect.md
@@ -85,10 +85,14 @@ function Component(t0) {
  let t1;
  if ($[0] !== prop) {
    const obj = shallowCopy(prop);
+
    const aliasedObj = identity(obj);
+
    const getId = () => obj.id;
+
    mutate(aliasedObj);
    setPropertyByKey(aliasedObj, "id", prop.id + 1);
+
    t1 = <Stringify getId={getId} shouldInvokeFns={true} />;
    $[0] = prop;
    $[1] = t1;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/aliased-nested-scope-truncated-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/aliased-nested-scope-truncated-dep.expect.md
@@ -181,9 +181,12 @@ function Component(t0) {
  if ($[0] !== prop) {
    const obj = shallowCopy(prop);
    const aliasedObj = identity(obj);
+
    const id = [obj.id];
+
    mutate(aliasedObj);
    setPropertyByKey(aliasedObj, "id", prop.id + 1);
+
    t1 = <Stringify id={id} />;
    $[0] = prop;
    $[1] = t1;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/align-scopes-within-nested-valueblock-in-array.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/align-scopes-within-nested-valueblock-in-array.expect.md
@@ -54,6 +54,7 @@ function Foo(t0) {
  let t1;
  if ($[0] !== cond1 || $[1] !== cond2) {
    const arr = makeArray({ a: 2 }, 2, []);
+
    t1 = cond1 ? (
      <>
        <div>{identity("foo")}</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-modify-global-in-callback-jsx.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-modify-global-in-callback-jsx.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @enablePreserveExistingMemoizationGuarantees:false @validateExhaustiveMemoizationDependencies:false
+// @enablePreserveExistingMemoizationGuarantees:false
 import {useMemo} from 'react';

 const someGlobal = {value: 0};
@@ -33,7 +33,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-import { c as _c } from "react/compiler-runtime"; // @enablePreserveExistingMemoizationGuarantees:false @validateExhaustiveMemoizationDependencies:false
+import { c as _c } from "react/compiler-runtime"; // @enablePreserveExistingMemoizationGuarantees:false
 import { useMemo } from "react";

 const someGlobal = { value: 0 };
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-modify-global-in-callback-jsx.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-modify-global-in-callback-jsx.js
@@ -1,4 +1,4 @@
-// @enablePreserveExistingMemoizationGuarantees:false @validateExhaustiveMemoizationDependencies:false
+// @enablePreserveExistingMemoizationGuarantees:false
 import {useMemo} from 'react';

 const someGlobal = {value: 0};
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-mutating-ref-in-callback-passed-to-jsx-indirect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-mutating-ref-in-callback-passed-to-jsx-indirect.expect.md
@@ -49,6 +49,7 @@ function Component() {
        ref.current = "";
      }
    };
+
    t0 = () => {
      setRef();
    };
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-mutating-ref-property-in-callback-passed-to-jsx-indirect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-mutating-ref-property-in-callback-passed-to-jsx-indirect.expect.md
@@ -49,6 +49,7 @@ function Component() {
        ref.current.value = "";
      }
    };
+
    t0 = () => {
      setRef();
    };
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-async-event-handler-wrapper.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-async-event-handler-wrapper.expect.md
@@ -1,148 +0,0 @@
-
-## Input
-
-```javascript
-// @enableInferEventHandlers
-import {useRef} from 'react';
-
-// Simulates react-hook-form's handleSubmit
-function handleSubmit<T>(callback: (data: T) => void | Promise<void>) {
-  return (event: any) => {
-    event.preventDefault();
-    callback({} as T);
-  };
-}
-
-// Simulates an upload function
-async function upload(file: any): Promise<{blob: {url: string}}> {
-  return {blob: {url: 'https://example.com/file.jpg'}};
-}
-
-interface SignatureRef {
-  toFile(): any;
-}
-
-function Component() {
-  const ref = useRef<SignatureRef>(null);
-
-  const onSubmit = async (value: any) => {
-    // This should be allowed: accessing ref.current in an async event handler
-    // that's wrapped and passed to onSubmit prop
-    let sigUrl: string;
-    if (value.hasSignature) {
-      const {blob} = await upload(ref.current?.toFile());
-      sigUrl = blob?.url || '';
-    } else {
-      sigUrl = value.signature;
-    }
-    console.log('Signature URL:', sigUrl);
-  };
-
-  return (
-    <form onSubmit={handleSubmit(onSubmit)}>
-      <input type="text" name="signature" />
-      <button type="submit">Submit</button>
-    </form>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enableInferEventHandlers
-import { useRef } from "react";
-
-// Simulates react-hook-form's handleSubmit
-function handleSubmit(callback) {
-  const $ = _c(2);
-  let t0;
-  if ($[0] !== callback) {
-    t0 = (event) => {
-      event.preventDefault();
-      callback({} as T);
-    };
-    $[0] = callback;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-// Simulates an upload function
-async function upload(file) {
-  const $ = _c(1);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = { blob: { url: "https://example.com/file.jpg" } };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return t0;
-}
-
-interface SignatureRef {
-  toFile(): any;
-}
-
-function Component() {
-  const $ = _c(4);
-  const ref = useRef(null);
-
-  const onSubmit = async (value) => {
-    let sigUrl;
-    if (value.hasSignature) {
-      const { blob } = await upload(ref.current?.toFile());
-      sigUrl = blob?.url || "";
-    } else {
-      sigUrl = value.signature;
-    }
-
-    console.log("Signature URL:", sigUrl);
-  };
-
-  const t0 = handleSubmit(onSubmit);
-  let t1;
-  let t2;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = <input type="text" name="signature" />;
-    t2 = <button type="submit">Submit</button>;
-    $[0] = t1;
-    $[1] = t2;
-  } else {
-    t1 = $[0];
-    t2 = $[1];
-  }
-  let t3;
-  if ($[2] !== t0) {
-    t3 = (
-      <form onSubmit={t0}>
-        {t1}
-        {t2}
-      </form>
-    );
-    $[2] = t0;
-    $[3] = t3;
-  } else {
-    t3 = $[3];
-  }
-  return t3;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <form><input type="text" name="signature"><button type="submit">Submit</button></form>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-async-event-handler-wrapper.tsx
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-async-event-handler-wrapper.tsx
@@ -1,48 +0,0 @@
-// @enableInferEventHandlers
-import {useRef} from 'react';
-
-// Simulates react-hook-form's handleSubmit
-function handleSubmit<T>(callback: (data: T) => void | Promise<void>) {
-  return (event: any) => {
-    event.preventDefault();
-    callback({} as T);
-  };
-}
-
-// Simulates an upload function
-async function upload(file: any): Promise<{blob: {url: string}}> {
-  return {blob: {url: 'https://example.com/file.jpg'}};
-}
-
-interface SignatureRef {
-  toFile(): any;
-}
-
-function Component() {
-  const ref = useRef<SignatureRef>(null);
-
-  const onSubmit = async (value: any) => {
-    // This should be allowed: accessing ref.current in an async event handler
-    // that's wrapped and passed to onSubmit prop
-    let sigUrl: string;
-    if (value.hasSignature) {
-      const {blob} = await upload(ref.current?.toFile());
-      sigUrl = blob?.url || '';
-    } else {
-      sigUrl = value.signature;
-    }
-    console.log('Signature URL:', sigUrl);
-  };
-
-  return (
-    <form onSubmit={handleSubmit(onSubmit)}>
-      <input type="text" name="signature" />
-      <button type="submit">Submit</button>
-    </form>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-event-handler-wrapper.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-event-handler-wrapper.expect.md
@@ -1,100 +0,0 @@
-
-## Input
-
-```javascript
-// @enableInferEventHandlers
-import {useRef} from 'react';
-
-// Simulates react-hook-form's handleSubmit or similar event handler wrappers
-function handleSubmit<T>(callback: (data: T) => void) {
-  return (event: any) => {
-    event.preventDefault();
-    callback({} as T);
-  };
-}
-
-function Component() {
-  const ref = useRef<HTMLInputElement>(null);
-
-  const onSubmit = (data: any) => {
-    // This should be allowed: accessing ref.current in an event handler
-    // that's wrapped by handleSubmit and passed to onSubmit prop
-    if (ref.current !== null) {
-      console.log(ref.current.value);
-    }
-  };
-
-  return (
-    <>
-      <input ref={ref} />
-      <form onSubmit={handleSubmit(onSubmit)}>
-        <button type="submit">Submit</button>
-      </form>
-    </>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enableInferEventHandlers
-import { useRef } from "react";
-
-// Simulates react-hook-form's handleSubmit or similar event handler wrappers
-function handleSubmit(callback) {
-  const $ = _c(2);
-  let t0;
-  if ($[0] !== callback) {
-    t0 = (event) => {
-      event.preventDefault();
-      callback({} as T);
-    };
-    $[0] = callback;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-function Component() {
-  const $ = _c(1);
-  const ref = useRef(null);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    const onSubmit = (data) => {
-      if (ref.current !== null) {
-        console.log(ref.current.value);
-      }
-    };
-    t0 = (
-      <>
-        <input ref={ref} />
-        <form onSubmit={handleSubmit(onSubmit)}>
-          <button type="submit">Submit</button>
-        </form>
-      </>
-    );
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return t0;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
-
-```
-      
-### Eval output
-(kind: ok) <input><form><button type="submit">Submit</button></form>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-event-handler-wrapper.tsx
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-access-in-event-handler-wrapper.tsx
@@ -1,36 +0,0 @@
-// @enableInferEventHandlers
-import {useRef} from 'react';
-
-// Simulates react-hook-form's handleSubmit or similar event handler wrappers
-function handleSubmit<T>(callback: (data: T) => void) {
-  return (event: any) => {
-    event.preventDefault();
-    callback({} as T);
-  };
-}
-
-function Component() {
-  const ref = useRef<HTMLInputElement>(null);
-
-  const onSubmit = (data: any) => {
-    // This should be allowed: accessing ref.current in an event handler
-    // that's wrapped by handleSubmit and passed to onSubmit prop
-    if (ref.current !== null) {
-      console.log(ref.current.value);
-    }
-  };
-
-  return (
-    <>
-      <input ref={ref} />
-      <form onSubmit={handleSubmit(onSubmit)}>
-        <button type="submit">Submit</button>
-      </form>
-    </>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{}],
-};
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-type-cast-in-render.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/allow-ref-type-cast-in-render.expect.md
@@ -36,6 +36,7 @@ function useArrayOfRef() {
    const callback = (value) => {
      ref.current = value;
    };
+
    t0 = [callback];
    $[0] = t0;
  } else {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-at-closure.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-at-closure.expect.md
@@ -35,6 +35,7 @@ function Component(props) {
      const arr = [...bar(props)];
      return arr.at(x);
    };
+
    t1 = fn();
    $[2] = props;
    $[3] = x;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-pattern-spread-creates-array.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-pattern-spread-creates-array.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validatePreserveExistingMemoizationGuarantees @validateExhaustiveMemoizationDependencies:false
+// @validatePreserveExistingMemoizationGuarantees
 import {useMemo} from 'react';
 import {makeObject_Primitives, ValidateMemoization} from 'shared-runtime';

@@ -36,7 +36,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-import { c as _c } from "react/compiler-runtime"; // @validatePreserveExistingMemoizationGuarantees @validateExhaustiveMemoizationDependencies:false
+import { c as _c } from "react/compiler-runtime"; // @validatePreserveExistingMemoizationGuarantees
 import { useMemo } from "react";
 import { makeObject_Primitives, ValidateMemoization } from "shared-runtime";

--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-pattern-spread-creates-array.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-pattern-spread-creates-array.js
@@ -1,4 +1,4 @@
-// @validatePreserveExistingMemoizationGuarantees @validateExhaustiveMemoizationDependencies:false
+// @validatePreserveExistingMemoizationGuarantees
 import {useMemo} from 'react';
 import {makeObject_Primitives, ValidateMemoization} from 'shared-runtime';

--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-spread-mutable-iterator.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/array-spread-mutable-iterator.expect.md
@@ -61,6 +61,7 @@ function useBar(t0) {
  if ($[0] !== arg) {
    const s = new Set([1, 5, 4]);
    const mutableIterator = s.values();
+
    t1 = [arg, ...mutableIterator];
    $[0] = arg;
    $[1] = t1;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md
@@ -2,7 +2,6 @@
 ## Input

 ```javascript
-// @validateExhaustiveMemoizationDependencies:false
 import {useMemo} from 'react';

 function Component(props) {
@@ -31,7 +30,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-import { c as _c } from "react/compiler-runtime"; // @validateExhaustiveMemoizationDependencies:false
+import { c as _c } from "react/compiler-runtime";
 import { useMemo } from "react";

 function Component(props) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/block-scoping-switch-variable-scoping.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/block-scoping-switch-variable-scoping.js
@@ -1,4 +1,3 @@
-// @validateExhaustiveMemoizationDependencies:false
 import {useMemo} from 'react';

 function Component(props) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/call.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/call.expect.md
@@ -28,6 +28,7 @@ function Component(props) {
    const a = [];
    const b = {};
    foo(a, b);
+
    foo(b);
    t0 = <div a={a} b={b} />;
    $[0] = t0;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/capture-ref-for-later-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/capture-ref-for-later-mutation.expect.md
@@ -45,6 +45,7 @@ function useKeyCommand() {
      const nextPosition = direction === "left" ? addOne(position) : position;
      currentPosition.current = nextPosition;
    };
+
    const moveLeft = { handler: handleKey("left") };
    const moveRight = { handler: handleKey("right") };
    t0 = [moveLeft, moveRight];
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/capturing-func-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/capturing-func-mutate.expect.md
@@ -45,6 +45,7 @@ function Component(t0) {
      z.a = 2;
      mutate(y.b);
    };
+
    x();
    t1 = [y, z];
    $[0] = a;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-emit-make-read-only.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-emit-make-read-only.expect.md
@@ -29,6 +29,7 @@ function MyComponentName(props) {
    const x = {};
    foo(x, props.a);
    foo(x, props.b);
+
    y = [];
    y.push(x);
    $[0] = props.a;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-inline-iife-reassign.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-inline-iife-reassign.expect.md
@@ -34,6 +34,7 @@ function useTest() {
  let t0;
  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
    let w = {};
+
    const t1 = (w = 42);
    const t2 = w;

--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-inline-iife-storeprop.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/codegen-inline-iife-storeprop.expect.md
@@ -34,6 +34,7 @@ function useTest() {
  let t0;
  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
    const w = {};
+
    const t1 = (w.x = 42);
    const t2 = w.x;

--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/conditional-on-mutable.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/conditional-on-mutable.expect.md
@@ -44,9 +44,11 @@ function ComponentA(props) {
    if (b) {
      a.push(props.p0);
    }
+
    if (props.p1) {
      b.push(props.p2);
    }
+
    t0 = <Foo a={a} b={b} />;
    $[0] = props.p0;
    $[1] = props.p1;
@@ -67,9 +69,11 @@ function ComponentB(props) {
    if (mayMutate(b)) {
      a.push(props.p0);
    }
+
    if (props.p1) {
      b.push(props.p2);
    }
+
    t0 = <Foo a={a} b={b} />;
    $[0] = props.p0;
    $[1] = props.p1;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/constructor.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/constructor.expect.md
@@ -28,6 +28,7 @@ function Component(props) {
    const a = [];
    const b = {};
    new Foo(a, b);
+
    new Foo(b);
    t0 = <div a={a} b={b} />;
    $[0] = t0;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-as-jsx-element-tag.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-as-jsx-element-tag.expect.md
@@ -11,7 +11,7 @@ function Component(props) {

  Component = useMemo(() => {
    return Component;
-  }, [Component]);
+  });

  return <Component {...props} />;
 }
@@ -36,7 +36,6 @@ function Component(props) {
  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
    Component = Stringify;

-    Component;
    Component = Component;
    $[0] = Component;
  } else {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-as-jsx-element-tag.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-as-jsx-element-tag.js
@@ -7,7 +7,7 @@ function Component(props) {

  Component = useMemo(() => {
    return Component;
-  }, [Component]);
+  });

  return <Component {...props} />;
 }
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-reassigned-outside-of-lambda.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/context-variable-reassigned-outside-of-lambda.expect.md
@@ -34,6 +34,7 @@ function Component(props) {
    const callback = () => {
      console.log(x);
    };
+
    x = {};
    t0 = <Stringify callback={callback} shouldInvokeFns={true} />;
    $[0] = t0;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
@@ -75,6 +75,7 @@ function Component(props) {
  let t0;
  if ($[0] !== post) {
    const allUrls = [];
+
    const { media: t1, comments: t2, urls: t3 } = post;
    const media = t1 === undefined ? null : t1;
    let t4;
@@ -101,6 +102,7 @@ function Component(props) {
        if (!comments.length) {
          return;
        }
+
        console.log(comments.length);
      };
      $[6] = comments.length;
@@ -109,6 +111,7 @@ function Component(props) {
      t6 = $[7];
    }
    const onClick = t6;
+
    allUrls.push(...urls);
    t0 = <Stringify media={media} allUrls={allUrls} onClick={onClick} />;
    $[0] = post;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
@@ -53,6 +53,7 @@ function Component(props) {
  let t0;
  if ($[0] !== post) {
    const allUrls = [];
+
    const { media, comments, urls } = post;
    let t1;
    if ($[2] !== comments.length) {
@@ -60,6 +61,7 @@ function Component(props) {
        if (!comments.length) {
          return;
        }
+
        console.log(comments.length);
      };
      $[2] = comments.length;
@@ -68,6 +70,7 @@ function Component(props) {
      t1 = $[3];
    }
    const onClick = t1;
+
    allUrls.push(...urls);
    t0 = <Media media={media} onClick={onClick} />;
    $[0] = post;
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/dont-merge-if-dep-is-inner-declaration-of-previous-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/dont-merge-if-dep-is-inner-declaration-of-previous-scope.expect.md
@@ -57,6 +57,7 @@ function Component(t0) {
  let y;
  if ($[0] !== a || $[1] !== b || $[2] !== c) {
    x = [];
+
    if (a) {
      let t1;
      if ($[5] !== b) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-conditionally-in-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-conditionally-in-effect.expect.md
@@ -1,64 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import {useEffect, useState} from 'react';
-
-function Component({value, enabled}) {
-  const [localValue, setLocalValue] = useState('');
-
-  useEffect(() => {
-    if (enabled) {
-      setLocalValue(value);
-    } else {
-      setLocalValue('disabled');
-    }
-  }, [value, enabled]);
-
-  return <div>{localValue}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{value: 'test', enabled: true}],
-};
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import { useEffect, useState } from "react";
-
-function Component({ value, enabled }) {
-  const [localValue, setLocalValue] = useState("");
-
-  useEffect(() => {
-    if (enabled) {
-      setLocalValue(value);
-    } else {
-      setLocalValue("disabled");
-    }
-  }, [value, enabled]);
-
-  return <div>{localValue}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ value: "test", enabled: true }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [value]\n\nData Flow Tree:\n└── value (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":9,"column":6,"index":263},"end":{"line":9,"column":19,"index":276},"filename":"derived-state-conditionally-in-effect.ts","identifierName":"setLocalValue"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":16,"column":1,"index":397},"filename":"derived-state-conditionally-in-effect.ts"},"fnName":"Component","memoSlots":6,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) <div>test</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-default-props.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-default-props.expect.md
@@ -1,58 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import {useEffect, useState} from 'react';
-
-export default function Component({input = 'empty'}) {
-  const [currInput, setCurrInput] = useState(input);
-  const localConst = 'local const';
-
-  useEffect(() => {
-    setCurrInput(input + localConst);
-  }, [input, localConst]);
-
-  return <div>{currInput}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{input: 'test'}],
-};
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import { useEffect, useState } from "react";
-
-export default function Component({ input = "empty" }) {
-  const [currInput, setCurrInput] = useState(input);
-  const localConst = "local const";
-
-  useEffect(() => {
-    setCurrInput(input + localConst);
-  }, [input, localConst]);
-
-  return <div>{currInput}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ input: "test" }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [input]\n\nData Flow Tree:\n└── input (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":9,"column":4,"index":295},"end":{"line":9,"column":16,"index":307},"filename":"derived-state-from-default-props.ts","identifierName":"setCurrInput"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":15,"index":141},"end":{"line":13,"column":1,"index":391},"filename":"derived-state-from-default-props.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) <div>testlocal const</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-local-state-in-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-local-state-in-effect.expect.md
@@ -1,52 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-import {useEffect, useState} from 'react';
-
-function Component({shouldChange}) {
-  const [count, setCount] = useState(0);
-
-  useEffect(() => {
-    if (shouldChange) {
-      setCount(count + 1);
-    }
-  }, [count]);
-
-  return <div>{count}</div>;
-}
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-import { useEffect, useState } from "react";
-
-function Component({ shouldChange }) {
-  const [count, setCount] = useState(0);
-
-  useEffect(() => {
-    if (shouldChange) {
-      setCount(count + 1);
-    }
-  }, [count]);
-
-  return <div>{count}</div>;
-}
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nState: [count]\n\nData Flow Tree:\n└── count (State)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":10,"column":6,"index":256},"end":{"line":10,"column":14,"index":264},"filename":"derived-state-from-local-state-in-effect.ts","identifierName":"setCount"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":5,"column":0,"index":127},"end":{"line":15,"column":1,"index":329},"filename":"derived-state-from-local-state-in-effect.ts"},"fnName":"Component","memoSlots":7,"memoBlocks":3,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-local-state-and-component-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-local-state-and-component-scope.expect.md
@@ -1,72 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import {useEffect, useState} from 'react';
-
-function Component({firstName}) {
-  const [lastName, setLastName] = useState('Doe');
-  const [fullName, setFullName] = useState('John');
-
-  const middleName = 'D.';
-
-  useEffect(() => {
-    setFullName(firstName + ' ' + middleName + ' ' + lastName);
-  }, [firstName, middleName, lastName]);
-
-  return (
-    <div>
-      <input value={lastName} onChange={e => setLastName(e.target.value)} />
-      <div>{fullName}</div>
-    </div>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{firstName: 'John'}],
-};
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import { useEffect, useState } from "react";
-
-function Component({ firstName }) {
-  const [lastName, setLastName] = useState("Doe");
-  const [fullName, setFullName] = useState("John");
-
-  const middleName = "D.";
-
-  useEffect(() => {
-    setFullName(firstName + " " + middleName + " " + lastName);
-  }, [firstName, middleName, lastName]);
-
-  return (
-    <div>
-      <input value={lastName} onChange={(e) => setLastName(e.target.value)} />
-      <div>{fullName}</div>
-    </div>
-  );
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ firstName: "John" }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [firstName]\nState: [lastName]\n\nData Flow Tree:\n├── firstName (Prop)\n└── lastName (State)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":11,"column":4,"index":316},"end":{"line":11,"column":15,"index":327},"filename":"derived-state-from-prop-local-state-and-component-scope.ts","identifierName":"setFullName"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":20,"column":1,"index":561},"filename":"derived-state-from-prop-local-state-and-component-scope.ts"},"fnName":"Component","memoSlots":12,"memoBlocks":5,"memoValues":6,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) <div><input value="Doe"><div>John D. Doe</div></div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-call-outside-effect-no-error.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-call-outside-effect-no-error.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({initialName}) {
@@ -29,21 +29,48 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+import { c as _c } from "react/compiler-runtime"; // @validateNoDerivedComputationsInEffects_exp
 import { useEffect, useState } from "react";

-function Component({ initialName }) {
+function Component(t0) {
+  const $ = _c(6);
+  const { initialName } = t0;
  const [name, setName] = useState("");
-
-  useEffect(() => {
-    setName(initialName);
-  }, [initialName]);
-
-  return (
-    <div>
-      <input value={name} onChange={(e) => setName(e.target.value)} />
-    </div>
-  );
+  let t1;
+  let t2;
+  if ($[0] !== initialName) {
+    t1 = () => {
+      setName(initialName);
+    };
+    t2 = [initialName];
+    $[0] = initialName;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = (e) => setName(e.target.value);
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  let t4;
+  if ($[4] !== name) {
+    t4 = (
+      <div>
+        <input value={name} onChange={t3} />
+      </div>
+    );
+    $[4] = name;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  return t4;
 }

 export const FIXTURE_ENTRYPOINT = {
@@ -52,12 +79,6 @@ export const FIXTURE_ENTRYPOINT = {
 };

 ```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":16,"column":1,"index":378},"filename":"derived-state-from-prop-setter-call-outside-effect-no-error.ts"},"fnName":"Component","memoSlots":6,"memoBlocks":3,"memoValues":4,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
      
 ### Eval output
 (kind: ok) <div><input value="John"></div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-call-outside-effect-no-error.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-call-outside-effect-no-error.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({initialName}) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-ternary.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-ternary.expect.md
@@ -1,37 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @outputMode:"lint"
-
-function Component({value}) {
-  const [checked, setChecked] = useState('');
-
-  useEffect(() => {
-    setChecked(value === '' ? [] : value.split(','));
-  }, [value]);
-
-  return <div>{checked}</div>;
-}
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @outputMode:"lint"
-
-function Component({ value }) {
-  const [checked, setChecked] = useState("");
-
-  useEffect(() => {
-    setChecked(value === "" ? [] : value.split(","));
-  }, [value]);
-
-  return <div>{checked}</div>;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-used-outside-effect-no-error.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-used-outside-effect-no-error.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function MockComponent({onSet}) {
@@ -28,20 +28,50 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+import { c as _c } from "react/compiler-runtime"; // @validateNoDerivedComputationsInEffects_exp
 import { useEffect, useState } from "react";

-function MockComponent({ onSet }) {
-  return <div onClick={() => onSet("clicked")}>Mock Component</div>;
+function MockComponent(t0) {
+  const $ = _c(2);
+  const { onSet } = t0;
+  let t1;
+  if ($[0] !== onSet) {
+    t1 = <div onClick={() => onSet("clicked")}>Mock Component</div>;
+    $[0] = onSet;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
 }

-function Component({ propValue }) {
-  const [value, setValue] = useState(null);
-  useEffect(() => {
-    setValue(propValue);
-  }, [propValue]);
-
-  return <MockComponent onSet={setValue} />;
+function Component(t0) {
+  const $ = _c(4);
+  const { propValue } = t0;
+  const [, setValue] = useState(null);
+  let t1;
+  let t2;
+  if ($[0] !== propValue) {
+    t1 = () => {
+      setValue(propValue);
+    };
+    t2 = [propValue];
+    $[0] = propValue;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <MockComponent onSet={setValue} />;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  return t3;
 }

 export const FIXTURE_ENTRYPOINT = {
@@ -50,13 +80,6 @@ export const FIXTURE_ENTRYPOINT = {
 };

 ```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":6,"column":1,"index":230},"filename":"derived-state-from-prop-setter-used-outside-effect-no-error.ts"},"fnName":"MockComponent","memoSlots":2,"memoBlocks":1,"memoValues":1,"prunedMemoBlocks":0,"prunedMemoValues":0}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":8,"column":0,"index":232},"end":{"line":15,"column":1,"index":421},"filename":"derived-state-from-prop-setter-used-outside-effect-no-error.ts"},"fnName":"Component","memoSlots":4,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
      
 ### Eval output
 (kind: ok) <div>Mock Component</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-used-outside-effect-no-error.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-setter-used-outside-effect-no-error.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function MockComponent({onSet}) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-with-side-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-prop-with-side-effect.expect.md
@@ -1,58 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import {useEffect, useState} from 'react';
-
-function Component({value}) {
-  const [localValue, setLocalValue] = useState('');
-
-  useEffect(() => {
-    setLocalValue(value);
-    document.title = `Value: ${value}`;
-  }, [value]);
-
-  return <div>{localValue}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{value: 'test'}],
-};
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import { useEffect, useState } from "react";
-
-function Component({ value }) {
-  const [localValue, setLocalValue] = useState("");
-
-  useEffect(() => {
-    setLocalValue(value);
-    document.title = `Value: ${value}`;
-  }, [value]);
-
-  return <div>{localValue}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ value: "test" }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [value]\n\nData Flow Tree:\n└── value (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":8,"column":4,"index":233},"end":{"line":8,"column":17,"index":246},"filename":"derived-state-from-prop-with-side-effect.ts","identifierName":"setLocalValue"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":13,"column":1,"index":346},"filename":"derived-state-from-prop-with-side-effect.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) <div>test</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-ref-and-state-no-error.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-ref-and-state-no-error.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState, useRef} from 'react';

 export default function Component({test}) {
@@ -27,19 +27,39 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+import { c as _c } from "react/compiler-runtime"; // @validateNoDerivedComputationsInEffects_exp
 import { useEffect, useState, useRef } from "react";

-export default function Component({ test }) {
+export default function Component(t0) {
+  const $ = _c(5);
+  const { test } = t0;
  const [local, setLocal] = useState("");

  const myRef = useRef(null);
-
-  useEffect(() => {
-    setLocal(myRef.current + test);
-  }, [test]);
-
-  return <>{local}</>;
+  let t1;
+  let t2;
+  if ($[0] !== test) {
+    t1 = () => {
+      setLocal(myRef.current + test);
+    };
+    t2 = [test];
+    $[0] = test;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] !== local) {
+    t3 = <>{local}</>;
+    $[3] = local;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
 }

 export const FIXTURE_ENTRYPOINT = {
@@ -48,12 +68,6 @@ export const FIXTURE_ENTRYPOINT = {
 };

 ```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":15,"index":149},"end":{"line":14,"column":1,"index":347},"filename":"derived-state-from-ref-and-state-no-error.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
      
 ### Eval output
 (kind: ok) nulltestString
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-ref-and-state-no-error.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/derived-state-from-ref-and-state-no-error.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState, useRef} from 'react';

 export default function Component({test}) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-local-function-call.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-local-function-call.expect.md
@@ -1,67 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import {useEffect, useState} from 'react';
-
-function Component({propValue}) {
-  const [value, setValue] = useState(null);
-
-  function localFunction() {
-    console.log('local function');
-  }
-
-  useEffect(() => {
-    setValue(propValue);
-    localFunction();
-  }, [propValue]);
-
-  return <div>{value}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{propValue: 'test'}],
-};
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-import { useEffect, useState } from "react";
-
-function Component({ propValue }) {
-  const [value, setValue] = useState(null);
-
-  function localFunction() {
-    console.log("local function");
-  }
-
-  useEffect(() => {
-    setValue(propValue);
-    localFunction();
-  }, [propValue]);
-
-  return <div>{value}</div>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ propValue: "test" }],
-};
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [propValue]\n\nData Flow Tree:\n└── propValue (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":12,"column":4,"index":298},"end":{"line":12,"column":12,"index":306},"filename":"effect-contains-local-function-call.ts","identifierName":"setValue"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":17,"column":1,"index":390},"filename":"effect-contains-local-function-call.ts"},"fnName":"Component","memoSlots":6,"memoBlocks":3,"memoValues":4,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: ok) <div>test</div>
-logs: ['local function']
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-prop-function-call-no-error.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-prop-function-call-no-error.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({propValue, onChange}) {
@@ -25,17 +25,43 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+import { c as _c } from "react/compiler-runtime"; // @validateNoDerivedComputationsInEffects_exp
 import { useEffect, useState } from "react";

-function Component({ propValue, onChange }) {
+function Component(t0) {
+  const $ = _c(7);
+  const { propValue, onChange } = t0;
  const [value, setValue] = useState(null);
-  useEffect(() => {
-    setValue(propValue);
-    onChange();
-  }, [propValue]);
-
-  return <div>{value}</div>;
+  let t1;
+  if ($[0] !== onChange || $[1] !== propValue) {
+    t1 = () => {
+      setValue(propValue);
+      onChange();
+    };
+    $[0] = onChange;
+    $[1] = propValue;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== propValue) {
+    t2 = [propValue];
+    $[3] = propValue;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[5] !== value) {
+    t3 = <div>{value}</div>;
+    $[5] = value;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
 }

 export const FIXTURE_ENTRYPOINT = {
@@ -44,13 +70,6 @@ export const FIXTURE_ENTRYPOINT = {
 };

 ```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":12,"column":1,"index":325},"filename":"effect-contains-prop-function-call-no-error.ts"},"fnName":"Component","memoSlots":7,"memoBlocks":3,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":16,"column":41,"index":421},"end":{"line":16,"column":49,"index":429},"filename":"effect-contains-prop-function-call-no-error.ts"},"fnName":null,"memoSlots":0,"memoBlocks":0,"memoValues":0,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
      
 ### Eval output
 (kind: ok) <div>test</div>
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-prop-function-call-no-error.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-contains-prop-function-call-no-error.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({propValue, onChange}) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-used-in-dep-array-still-errors.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-used-in-dep-array-still-errors.expect.md
@@ -1,42 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-function Component({prop}) {
-  const [s, setS] = useState(0);
-  useEffect(() => {
-    setS(prop);
-  }, [prop, setS]);
-
-  return <div>{prop}</div>;
-}
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-function Component({ prop }) {
-  const [s, setS] = useState(0);
-  useEffect(() => {
-    setS(prop);
-  }, [prop, setS]);
-
-  return <div>{prop}</div>;
-}
-
-```
-
-## Logs
-
-```
-{"kind":"CompileError","detail":{"options":{"description":"Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user\n\nThis setState call is setting a derived value that depends on the following reactive sources:\n\nProps: [prop]\n\nData Flow Tree:\n└── prop (Prop)\n\nSee: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state","category":"EffectDerivationsOfState","reason":"You might not need an effect. Derive values in render, not effects.","details":[{"kind":"error","loc":{"start":{"line":6,"column":4,"index":169},"end":{"line":6,"column":8,"index":173},"filename":"effect-used-in-dep-array-still-errors.ts","identifierName":"setS"},"message":"This should be computed during render, not in an effect"}]}},"fnLoc":null}
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":3,"column":0,"index":83},"end":{"line":10,"column":1,"index":231},"filename":"effect-used-in-dep-array-still-errors.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-used-in-dep-array-still-errors.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-used-in-dep-array-still-errors.js
@@ -1,10 +0,0 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-function Component({prop}) {
-  const [s, setS] = useState(0);
-  useEffect(() => {
-    setS(prop);
-  }, [prop, setS]);
-
-  return <div>{prop}</div>;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-cleanup-function-depending-on-derived-computation-value.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-cleanup-function-depending-on-derived-computation-value.expect.md
@@ -1,63 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-import {useEffect, useState} from 'react';
-
-function Component(file: File) {
-  const [imageUrl, setImageUrl] = useState(null);
-
-  /*
-   * Cleaning up the variable or a source of the variable used to setState
-   * inside the effect communicates that we always need to clean up something
-   * which is a valid use case for useEffect. In which case we want to
-   * avoid an throwing
-   */
-  useEffect(() => {
-    const imageUrlPrepared = URL.createObjectURL(file);
-    setImageUrl(imageUrlPrepared);
-    return () => URL.revokeObjectURL(imageUrlPrepared);
-  }, [file]);
-
-  return <Image src={imageUrl} xstyle={styles.imageSizeLimits} />;
-}
-
-```
-
-## Code
-
-```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-import { useEffect, useState } from "react";
-
-function Component(file: File) {
-  const [imageUrl, setImageUrl] = useState(null);
-
-  /*
-   * Cleaning up the variable or a source of the variable used to setState
-   * inside the effect communicates that we always need to clean up something
-   * which is a valid use case for useEffect. In which case we want to
-   * avoid an throwing
-   */
-  useEffect(() => {
-    const imageUrlPrepared = URL.createObjectURL(file);
-    setImageUrl(imageUrlPrepared);
-    return () => URL.revokeObjectURL(imageUrlPrepared);
-  }, [file]);
-
-  return <Image src={imageUrl} xstyle={styles.imageSizeLimits} />;
-}
-
-```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":5,"column":0,"index":127},"end":{"line":21,"column":1,"index":719},"filename":"effect-with-cleanup-function-depending-on-derived-computation-value.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-cleanup-function-depending-on-derived-computation-value.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-cleanup-function-depending-on-derived-computation-value.js
@@ -1,21 +0,0 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
-
-import {useEffect, useState} from 'react';
-
-function Component(file: File) {
-  const [imageUrl, setImageUrl] = useState(null);
-
-  /*
-   * Cleaning up the variable or a source of the variable used to setState
-   * inside the effect communicates that we always need to clean up something
-   * which is a valid use case for useEffect. In which case we want to
-   * avoid an throwing
-   */
-  useEffect(() => {
-    const imageUrlPrepared = URL.createObjectURL(file);
-    setImageUrl(imageUrlPrepared);
-    return () => URL.revokeObjectURL(imageUrlPrepared);
-  }, [file]);
-
-  return <Image src={imageUrl} xstyle={styles.imageSizeLimits} />;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-global-function-call-no-error.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-global-function-call-no-error.expect.md
@@ -2,7 +2,7 @@
 ## Input

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({propValue}) {
@@ -25,17 +25,38 @@ export const FIXTURE_ENTRYPOINT = {
 ## Code

 ```javascript
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+import { c as _c } from "react/compiler-runtime"; // @validateNoDerivedComputationsInEffects_exp
 import { useEffect, useState } from "react";

-function Component({ propValue }) {
+function Component(t0) {
+  const $ = _c(5);
+  const { propValue } = t0;
  const [value, setValue] = useState(null);
-  useEffect(() => {
-    setValue(propValue);
-    globalCall();
-  }, [propValue]);
-
-  return <div>{value}</div>;
+  let t1;
+  let t2;
+  if ($[0] !== propValue) {
+    t1 = () => {
+      setValue(propValue);
+      globalCall();
+    };
+    t2 = [propValue];
+    $[0] = propValue;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] !== value) {
+    t3 = <div>{value}</div>;
+    $[3] = value;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
 }

 export const FIXTURE_ENTRYPOINT = {
@@ -44,12 +65,6 @@ export const FIXTURE_ENTRYPOINT = {
 };

 ```
-
-## Logs
-
-```
-{"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":126},"end":{"line":12,"column":1,"index":317},"filename":"effect-with-global-function-call-no-error.ts"},"fnName":"Component","memoSlots":5,"memoBlocks":2,"memoValues":3,"prunedMemoBlocks":0,"prunedMemoValues":0}
-```
      
 ### Eval output
 (kind: exception) globalCall is not defined
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-global-function-call-no-error.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/effect-with-global-function-call-no-error.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({propValue}) {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/error.derived-state-conditionally-in-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/error.derived-state-conditionally-in-effect.expect.md
@@ -0,0 +1,58 @@
+
+## Input
+
+```javascript
+// @validateNoDerivedComputationsInEffects_exp
+import {useEffect, useState} from 'react';
+
+function Component({value, enabled}) {
+  const [localValue, setLocalValue] = useState('');
+
+  useEffect(() => {
+    if (enabled) {
+      setLocalValue(value);
+    } else {
+      setLocalValue('disabled');
+    }
+  }, [value, enabled]);
+
+  return <div>{localValue}</div>;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{value: 'test', enabled: true}],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Error: You might not need an effect. Derive values in render, not effects.
+
+Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user
+
+This setState call is setting a derived value that depends on the following reactive sources:
+
+Props: [value]
+
+Data Flow Tree:
+└── value (Prop)
+
+See: https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state.
+
+error.derived-state-conditionally-in-effect.ts:9:6
+   7 |   useEffect(() => {
+   8 |     if (enabled) {
+>  9 |       setLocalValue(value);
+     |       ^^^^^^^^^^^^^ This should be computed during render, not in an effect
+  10 |     } else {
+  11 |       setLocalValue('disabled');
+  12 |     }
+```
+          
+      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/error.derived-state-conditionally-in-effect.js
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/effect-derived-computations/error.derived-state-conditionally-in-effect.js
@@ -1,4 +1,4 @@
-// @validateNoDerivedComputationsInEffects_exp @loggerTestOnly @outputMode:"lint"
+// @validateNoDerivedComputationsInEffects_exp
 import {useEffect, useState} from 'react';

 function Component({value, enabled}) {
--- a/Show More
+++ b/Show More