[eprh] Remove __EXPERIMENTAL__

`__EXPERIMENTAL__` flag doesn't have any use outside of the React repo. Let's remove these flags for now.
[eprh] Move to compiler directory
2025-03-19 16:17:26 -04:00 · 2025-03-19 16:17:24 -04:00
2042 changed files with 31134 additions and 129420 deletions
--- a/.codesandbox/ci.json
+++ b/.codesandbox/ci.json
@@ -1,11 +1,10 @@
 {
-  "packages": ["packages/react", "packages/react-dom", "packages/react-server-dom-webpack", "packages/scheduler"],
+  "packages": ["packages/react", "packages/react-dom", "packages/scheduler"],
  "buildCommand": "download-build-in-codesandbox-ci",
  "node": "18",
  "publishDirectory": {
    "react": "build/oss-experimental/react",
    "react-dom": "build/oss-experimental/react-dom",
-    "react-server-dom-webpack": "build/oss-experimental/react-server-dom-webpack",
    "scheduler": "build/oss-experimental/scheduler"
  },
  "sandboxes": ["new"],
--- a/.eslintignore
+++ b/.eslintignore
@@ -28,6 +28,3 @@ packages/react-devtools-shared/src/hooks/__tests__/__source__/__untransformed__/
 packages/react-devtools-shell/dist
 packages/react-devtools-timeline/dist
 packages/react-devtools-timeline/static
-
-# Imported third-party Flow types
-flow-typed/
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -336,11 +336,11 @@ module.exports = {
        'packages/react-devtools-extensions/**/*.js',
        'packages/react-devtools-timeline/**/*.js',
        'packages/react-native-renderer/**/*.js',
-        'packages/eslint-plugin-react-hooks/**/*.js',
        'packages/jest-react/**/*.js',
        'packages/internal-test-utils/**/*.js',
        'packages/**/__tests__/*.js',
        'packages/**/npm/*.js',
+        'compiler/packages/eslint-plugin-react-hooks/**/*.js',
      ],
      rules: {
        'react-internal/prod-error-codes': OFF,
@@ -468,14 +468,13 @@ module.exports = {
      files: ['packages/react-server-dom-webpack/**/*.js'],
      globals: {
        __webpack_chunk_load__: 'readonly',
-        __webpack_get_script_filename__: 'readonly',
        __webpack_require__: 'readonly',
      },
    },
    {
      files: ['packages/react-server-dom-turbopack/**/*.js'],
      globals: {
-        __turbopack_load_by_url__: 'readonly',
+        __turbopack_load__: 'readonly',
        __turbopack_require__: 'readonly',
      },
    },
@@ -497,7 +496,6 @@ module.exports = {
        'packages/react-devtools-shared/src/devtools/views/**/*.js',
        'packages/react-devtools-shared/src/hook.js',
        'packages/react-devtools-shared/src/backend/console.js',
-        'packages/react-devtools-shared/src/backend/fiber/renderer.js',
        'packages/react-devtools-shared/src/backend/shared/DevToolsComponentStackFrame.js',
        'packages/react-devtools-shared/src/frontend/utils/withPermissionsCheck.js',
      ],
@@ -506,7 +504,6 @@ module.exports = {
        __IS_FIREFOX__: 'readonly',
        __IS_EDGE__: 'readonly',
        __IS_NATIVE__: 'readonly',
-        __IS_INTERNAL_MCP_BUILD__: 'readonly',
        __IS_INTERNAL_VERSION__: 'readonly',
        chrome: 'readonly',
      },
@@ -518,7 +515,7 @@ module.exports = {
      },
    },
    {
-      files: ['packages/eslint-plugin-react-hooks/src/**/*'],
+      files: ['compiler/packages/eslint-plugin-react-hooks/src/**/*'],
      extends: ['plugin:@typescript-eslint/recommended'],
      parser: '@typescript-eslint/parser',
      plugins: ['@typescript-eslint', 'eslint-plugin'],
@@ -547,10 +544,13 @@ module.exports = {
  },

  globals: {
+    $Call: 'readonly',
+    $ElementType: 'readonly',
    $Flow$ModuleRef: 'readonly',
    $FlowFixMe: 'readonly',
    $Keys: 'readonly',
    $NonMaybeType: 'readonly',
+    $PropertyType: 'readonly',
    $ReadOnly: 'readonly',
    $ReadOnlyArray: 'readonly',
    $ArrayBufferView: 'readonly',
@@ -559,13 +559,11 @@ module.exports = {
    ConsoleTask: 'readonly', // TOOD: Figure out what the official name of this will be.
    ReturnType: 'readonly',
    AnimationFrameID: 'readonly',
-    WeakRef: 'readonly',
    // For Flow type annotation. Only `BigInt` is valid at runtime.
    bigint: 'readonly',
    BigInt: 'readonly',
    BigInt64Array: 'readonly',
    BigUint64Array: 'readonly',
-    CacheType: 'readonly',
    Class: 'readonly',
    ClientRect: 'readonly',
    CopyInspectedElementPath: 'readonly',
@@ -580,15 +578,12 @@ module.exports = {
    IteratorResult: 'readonly',
    JSONValue: 'readonly',
    JSResourceReference: 'readonly',
-    mixin$Animatable: 'readonly',
    MouseEventHandler: 'readonly',
-    NavigateEvent: 'readonly',
-    PerformanceMeasureOptions: 'readonly',
    PropagationPhases: 'readonly',
    PropertyDescriptor: 'readonly',
-    PropertyDescriptorMap: 'readonly',
-    Proxy$traps: 'readonly',
+    React$AbstractComponent: 'readonly',
    React$Component: 'readonly',
+    React$ComponentType: 'readonly',
    React$Config: 'readonly',
    React$Context: 'readonly',
    React$Element: 'readonly',
@@ -609,21 +604,17 @@ module.exports = {
    symbol: 'readonly',
    SyntheticEvent: 'readonly',
    SyntheticMouseEvent: 'readonly',
-    SyntheticPointerEvent: 'readonly',
    Thenable: 'readonly',
    TimeoutID: 'readonly',
    WheelEventHandler: 'readonly',
    FinalizationRegistry: 'readonly',
-    Exclude: 'readonly',
    Omit: 'readonly',
    Keyframe: 'readonly',
    PropertyIndexedKeyframes: 'readonly',
    KeyframeAnimationOptions: 'readonly',
    GetAnimationsOptions: 'readonly',
+    Animatable: 'readonly',
    ScrollTimeline: 'readonly',
-    EventListenerOptionsOrUseCapture: 'readonly',
-    FocusOptions: 'readonly',
-    OptionalEffectTiming: 'readonly',

    spyOnDev: 'readonly',
    spyOnDevAndProd: 'readonly',
@@ -641,6 +632,5 @@ module.exports = {
    AsyncLocalStorage: 'readonly',
    async_hooks: 'readonly',
    globalThis: 'readonly',
-    navigation: 'readonly',
  },
 };
--- a/.github/ISSUE_TEMPLATE/19.md
+++ b/.github/ISSUE_TEMPLATE/19.md
@@ -0,0 +1,18 @@
+---
+name: "⚛React 19 beta issue"
+about: Report a issue with React 19 beta.
+title: '[React 19]'
+labels: 'React 19'
+
+---
+
+
+## Summary
+
+<!--
+  Please provide a CodeSandbox (https://codesandbox.io/s/new), a link to a
+  repository on GitHub, or provide a minimal code example that reproduces the
+  problem. You may provide a screenshot of the application if you think it is
+  relevant to your bug report. Here are some tips for providing a minimal
+  example: https://stackoverflow.com/help/mcve.
+-->
--- a/.github/workflows/compiler_discord_notify.yml
+++ b/.github/workflows/compiler_discord_notify.yml
@@ -7,28 +7,9 @@ on:
      - compiler/**
      - .github/workflows/compiler_**.yml

-permissions: {}
-
 jobs:
-  check_access:
-    if: ${{ github.event.pull_request.draft == false }}
-    runs-on: ubuntu-latest
-    outputs:
-      is_member_or_collaborator: ${{ steps.check_is_member_or_collaborator.outputs.is_member_or_collaborator }}
-    steps:
-      - run: echo ${{ github.event.pull_request.author_association }}
-      - name: Check is member or collaborator
-        id: check_is_member_or_collaborator
-        if: ${{ github.event.pull_request.author_association == 'MEMBER' || github.event.pull_request.author_association == 'COLLABORATOR' }}
-        run: echo "is_member_or_collaborator=true" >> "$GITHUB_OUTPUT"
-
  check_maintainer:
-    if: ${{ needs.check_access.outputs.is_member_or_collaborator == 'true' || needs.check_access.outputs.is_member_or_collaborator == true }}
-    needs: [check_access]
    uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
    with:
      actor: ${{ github.event.pull_request.user.login }}

--- a/.github/workflows/compiler_playground.yml
+++ b/.github/workflows/compiler_playground.yml
@@ -8,8 +8,6 @@ on:
      - compiler/**
      - .github/workflows/compiler_playground.yml

-permissions: {}
-
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
@@ -40,23 +38,9 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: compiler-and-playground-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        working-directory: compiler
-      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
      - run: npx playwright install --with-deps chromium
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
      - run: CI=true yarn test
      - run: ls -R test-results
        if: '!cancelled()'
@@ -66,4 +50,3 @@ jobs:
        with:
          name: test-results
          path: compiler/apps/playground/test-results
-          if-no-files-found: ignore
--- a/.github/workflows/compiler_prereleases.yml
+++ b/.github/workflows/compiler_prereleases.yml
@@ -16,19 +16,15 @@ on:
      version_name:
        required: true
        type: string
-      tag_version:
-        required: false
-        type: string
    secrets:
      NPM_TOKEN:
        required: true

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

 defaults:
@@ -52,10 +48,9 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Publish packages to npm
        run: |
          cp ./scripts/release/ci-npmrc ~/.npmrc
-          scripts/release/publish.js --frfr --ci --versionName=${{ inputs.version_name }} --tag=${{ inputs.dist_tag }} ${{ inputs.tag_version && format('--tagVersion={0}', inputs.tag_version) || '' }}
+          scripts/release/publish.js --frfr --ci --versionName=${{ inputs.version_name }} --tag ${{ inputs.dist_tag }}
--- a/.github/workflows/compiler_prereleases_manual.yml
+++ b/.github/workflows/compiler_prereleases_manual.yml
@@ -14,11 +14,6 @@ on:
      version_name:
        required: true
        type: string
-      tag_version:
-        required: false
-        type: string
-
-permissions: {}

 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
@@ -32,6 +27,5 @@ jobs:
      release_channel: ${{ inputs.release_channel }}
      dist_tag: ${{ inputs.dist_tag }}
      version_name: ${{ inputs.version_name }}
-      tag_version: ${{ inputs.tag_version }}
    secrets:
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/compiler_prereleases_nightly.yml
+++ b/.github/workflows/compiler_prereleases_nightly.yml
@@ -5,8 +5,6 @@ on:
    # At 10 minutes past 16:00 on Mon, Tue, Wed, Thu, and Fri
    - cron: 10 16 * * 1,2,3,4,5

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles

--- a/.github/workflows/compiler_prereleases_weekly.yml
+++ b/.github/workflows/compiler_prereleases_weekly.yml
@@ -0,0 +1,21 @@
+name: (Compiler) Publish Prereleases Weekly
+
+on:
+  schedule:
+    # At 10 minutes past 9:00 on Mon
+    - cron: 10 9 * * 1
+
+env:
+  TZ: /usr/share/zoneinfo/America/Los_Angeles
+
+jobs:
+  publish_prerelease_beta:
+    name: Publish to beta channel
+    uses: facebook/react/.github/workflows/compiler_prereleases.yml@main
+    with:
+      commit_sha: ${{ github.sha }}
+      release_channel: beta
+      dist_tag: beta
+      version_name: '19.0.0'
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/compiler_typescript.yml
+++ b/.github/workflows/compiler_typescript.yml
@@ -8,8 +8,6 @@ on:
      - compiler/**
      - .github/workflows/compiler_typescript.yml

-permissions: {}
-
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
@@ -47,13 +45,11 @@ jobs:
          cache-dependency-path: compiler/yarn.lock
      - name: Restore cached node_modules
        uses: actions/cache@v4
-        id: node_modules
        with:
          path: |
            **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn workspace babel-plugin-react-compiler lint

  # Hardcoded to improve parallelism
@@ -73,9 +69,8 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn workspace babel-plugin-react-compiler jest

  test:
@@ -99,9 +94,8 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/**/yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: xvfb-run -a yarn workspace ${{ matrix.workspace_name }} test
        if: runner.os == 'Linux' && matrix.workspace_name == 'react-forgive'
      - run: yarn workspace ${{ matrix.workspace_name }} test
--- a/.github/workflows/devtools_regression_tests.yml
+++ b/.github/workflows/devtools_regression_tests.yml
@@ -9,8 +9,6 @@ on:
        required: false
        type: string

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -20,9 +18,6 @@ jobs:
  download_build:
    name: Download base build
    runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
@@ -40,9 +35,7 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Download react-devtools artifacts for base revision
        run: |
          git fetch origin main
@@ -54,7 +47,6 @@ jobs:
        with:
          name: build
          path: build
-          if-no-files-found: error

  build_devtools_and_process_artifacts:
    name: Build DevTools and process artifacts
@@ -77,7 +69,6 @@ jobs:
      - 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:
@@ -93,20 +84,17 @@ jobs:
        with:
          name: react-devtools
          path: build/devtools.tgz
-          if-no-files-found: error
      # Simplifies getting the extension for local testing
      - name: Archive chrome extension
        uses: actions/upload-artifact@v4
        with:
          name: react-devtools-chrome-extension
          path: build/devtools/chrome-extension.zip
-          if-no-files-found: error
      - name: Archive firefox extension
        uses: actions/upload-artifact@v4
        with:
          name: react-devtools-firefox-extension
          path: build/devtools/firefox-extension.zip
-          if-no-files-found: error

  run_devtools_tests_for_versions:
    name: Run DevTools tests for versions
@@ -137,7 +125,6 @@ jobs:
            **/node_modules
          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Restore all archived build artifacts
        uses: actions/download-artifact@v4
      - name: Display structure of build
@@ -173,24 +160,14 @@ jobs:
            **/node_modules
          key: runtime-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Restore all archived build artifacts
        uses: actions/download-artifact@v4
      - name: Display structure of build
        run: ls -R build
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - run: npx playwright install --with-deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-      - run: npx playwright install-deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit == 'true'
+      - name: Playwright install deps
+        run: |
+          npx playwright install
+          sudo npx playwright install-deps
      - run: ./scripts/ci/download_devtools_regression_build.js ${{ matrix.version }}
      - run: ls -R build-regression
      - run: ./scripts/ci/run_devtools_e2e_tests.js ${{ matrix.version }}
@@ -202,4 +179,3 @@ jobs:
        with:
          name: screenshots
          path: ./tmp/screenshots
-          if-no-files-found: warn
--- a/.github/workflows/runtime_build_and_test.yml
+++ b/.github/workflows/runtime_build_and_test.yml
@@ -6,14 +6,6 @@ on:
  pull_request:
    paths-ignore:
      - compiler/**
-  workflow_dispatch:
-    inputs:
-      commit_sha:
-        required: false
-        type: string
-        default: ''
-
-permissions: {}

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
@@ -34,7 +26,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - name: Check cache hit
        uses: actions/cache/restore@v4
        id: node_modules
@@ -49,16 +41,6 @@ jobs:
          node-version-file: '.nvmrc'
          cache: yarn
          cache-dependency-path: yarn.lock
-      - name: Warm with old cache
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            **/node_modules
-          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
@@ -75,7 +57,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - name: Check cache hit
        uses: actions/cache/restore@v4
        id: node_modules
@@ -92,16 +74,6 @@ jobs:
          cache-dependency-path: |
            yarn.lock
            compiler/yarn.lock
-      - name: Warm with old cache
-        if: steps.node_modules.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            **/node_modules
-          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
@@ -123,7 +95,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/github-script@v7
        id: set-matrix
        with:
@@ -142,7 +114,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -155,9 +127,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -172,7 +141,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -185,9 +154,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -204,7 +170,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -260,7 +226,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -275,9 +241,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -286,37 +249,6 @@ jobs:
        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn test ${{ matrix.params }} --ci --shard=${{ matrix.shard }}

-  # Hardcoded to improve parallelism
-  test-linter:
-    name: Test eslint-plugin-react-hooks
-    needs: [runtime_compiler_node_modules_cache]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version-file: '.nvmrc'
-          cache: yarn
-          cache-dependency-path:  |
-            yarn.lock
-            compiler/yarn.lock
-      - name: Restore cached node_modules
-        uses: actions/cache@v4
-        id: node_modules
-        with:
-          path: |
-            **/node_modules
-          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'
-      - name: Install compiler dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: compiler
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: ./scripts/react-compiler/build-compiler.sh && ./scripts/react-compiler/link-compiler.sh
-      - run: yarn workspace eslint-plugin-react-hooks test
-
  # ----- BUILD -----
  build_and_lint:
    name: yarn build and lint
@@ -331,7 +263,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -350,9 +282,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -373,7 +302,6 @@ jobs:
        with:
          name: _build_${{ matrix.worker_id }}_${{ matrix.release_channel }}
          path: build
-          if-no-files-found: error

  test_build:
    name: yarn test-build
@@ -412,21 +340,14 @@ jobs:
          # TODO: Test more persistent configurations?
        ]
        shard:
-          - 1/10
-          - 2/10
-          - 3/10
-          - 4/10
-          - 5/10
-          - 6/10
-          - 7/10
-          - 8/10
-          - 9/10
-          - 10/10
+          - 1/3
+          - 2/3
+          - 3/3
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -441,9 +362,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -463,15 +381,11 @@ jobs:
  process_artifacts_combined:
    name: Process artifacts combined
    needs: [build_and_lint, runtime_node_modules_cache]
-    permissions:
-      # https://github.com/actions/attest-build-provenance
-      id-token: write
-      attestations: write
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -484,9 +398,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -499,7 +410,7 @@ jobs:
          merge-multiple: true
      - name: Display structure of build
        run: ls -R build
-      - run: echo ${{ github.event.inputs.commit_sha != '' && github.event.inputs.commit_sha || github.event.pull_request.head.sha || github.sha }} >> build/COMMIT_SHA
+      - run: echo ${{ github.event.pull_request.head.sha || github.sha }} >> build/COMMIT_SHA
      - name: Scrape warning messages
        run: |
          mkdir -p ./build/__test_utils__
@@ -509,25 +420,12 @@ jobs:
        # TODO: Migrate scripts to use `build` directory instead of `build2`
      - run: cp ./build.tgz ./build2.tgz
      - name: Archive build artifacts
-        id: upload_artifacts_combined
        uses: actions/upload-artifact@v4
        with:
          name: artifacts_combined
          path: |
            ./build.tgz
            ./build2.tgz
-          if-no-files-found: error
-      - uses: actions/attest-build-provenance@v2
-        # We don't verify builds generated from pull requests not originating from facebook/react.
-        # However, if the PR lands, the run on `main` will generate the attestation which can then
-        # be used to download a build via scripts/release/download-experimental-build.js.
-        #
-        # Note that this means that scripts/release/download-experimental-build.js must be run with
-        # --no-verify when downloading a build from a fork.
-        if: github.event_name == 'push' && github.ref_name == 'main' || github.event.pull_request.head.repo.full_name == github.repository
-        with:
-          subject-name: artifacts_combined.zip
-          subject-digest: sha256:${{ steps.upload_artifacts_combined.outputs.artifact-digest }}

  check_error_codes:
    name: Search build artifacts for unminified errors
@@ -536,7 +434,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -549,9 +447,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -576,7 +471,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -589,9 +484,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -613,7 +505,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -625,7 +517,7 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: fixtures_dom-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'fixtures/dom/yarn.lock') }}
+          key: fixtures_dom-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn --cwd fixtures/dom install --frozen-lockfile
@@ -654,7 +546,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -669,26 +561,11 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: fixtures_flight-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'fixtures/flight/yarn.lock') }}
+          key: fixtures_flight-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
        if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: yarn --cwd fixtures/flight install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - name: Playwright install deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-        working-directory: fixtures/flight
-        run: npx playwright install --with-deps chromium
      - name: Restore archived build
        uses: actions/download-artifact@v4
        with:
@@ -697,6 +574,16 @@ jobs:
          merge-multiple: true
      - name: Display structure of build
        run: ls -R build
+      - name: Install fixture dependencies
+        working-directory: fixtures/flight
+        run: |
+          yarn install --frozen-lockfile --cache-folder ~/.cache/yarn
+          if [ $? -ne 0 ]; then
+            yarn install --frozen-lockfile --cache-folder ~/.cache/yarn
+          fi
+      - name: Playwright install deps
+        working-directory: fixtures/flight
+        run: npx playwright install --with-deps chromium
      - name: Run tests
        working-directory: fixtures/flight
        run: yarn test
@@ -708,13 +595,11 @@ jobs:
        with:
          name: flight-playwright-report
          path: fixtures/flight/playwright-report
-          if-no-files-found: warn
      - name: Archive Flight fixture artifacts
        uses: actions/upload-artifact@v4
        with:
          name: flight-test-results
          path: fixtures/flight/test-results
-          if-no-files-found: ignore

  # ----- DEVTOOLS -----
  build_devtools_and_process_artifacts:
@@ -728,7 +613,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -741,9 +626,6 @@ jobs:
          path: |
            **/node_modules
          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,7 +647,6 @@ jobs:
        with:
          name: react-devtools-${{ matrix.browser }}-extension
          path: build/devtools/${{ matrix.browser }}-extension.zip
-          if-no-files-found: error

  merge_devtools_artifacts:
    name: Merge DevTools artifacts
@@ -785,7 +666,7 @@ jobs:
    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 }}
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
      - uses: actions/setup-node@v4
        with:
          node-version-file: '.nvmrc'
@@ -798,9 +679,6 @@ jobs:
          path: |
            **/node_modules
          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
@@ -811,18 +689,9 @@ jobs:
          pattern: _build_*
          path: build
          merge-multiple: true
-      - name: Check Playwright version
-        id: playwright_version
-        run: echo "playwright_version=$(npm ls @playwright/test | grep @playwright | sed 's/.*@//' | head -1)" >> "$GITHUB_OUTPUT"
-      - name: Cache Playwright Browsers for version ${{ steps.playwright_version.outputs.playwright_version }}
-        id: cache_playwright_browsers
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-browsers-v6-${{ runner.arch }}-${{ runner.os }}-${{ steps.playwright_version.outputs.playwright_version }}
-      - name: Playwright install deps
-        if: steps.cache_playwright_browsers.outputs.cache-hit != 'true'
-        run: npx playwright install --with-deps chromium
+      - run: |
+          npx playwright install
+          sudo npx playwright install-deps
      - run: ./scripts/ci/run_devtools_e2e_tests.js
        env:
          RELEASE_CHANNEL: experimental
@@ -831,22 +700,19 @@ jobs:
  sizebot:
    if: ${{ github.event_name == 'pull_request' && github.ref_name != 'main' && github.event.pull_request.base.ref == 'main' }}
    name: Run sizebot
-    needs: [build_and_lint]
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
+    needs: [build_and_lint, runtime_node_modules_cache]
    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 }}
+          ref: ${{ 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@v4 # note: this does not reuse centralized cache since it has unique cache key
+        uses: actions/cache/restore@v4
        id: node_modules
        with:
          path: |
@@ -859,23 +725,21 @@ jobs:
      - run: yarn --cwd scripts/release install --frozen-lockfile
        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Download artifacts for base revision
-        # The build could have been generated from a fork, so we must download the build without
-        # any verification. This is safe since we only use this for sizebot calculation and the
-        # unverified artifact is not used. Additionally this workflow runs in the pull_request
-        # trigger so only restricted permissions are available.
        run: |
-          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=$(git rev-parse ${{ github.event.pull_request.base.sha }}) ${{ (github.event.pull_request.head.repo.full_name != github.repository && '--noVerify') || ''}}
+          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=$(git rev-parse ${{ github.event.pull_request.base.sha }})
          mv ./build ./base-build
+      # TODO: The `download-experimental-build` script copies the npm
+      # packages into the `node_modules` directory. This is a historical
+      # quirk of how the release script works. Let's pretend they
+      # don't exist.
      - name: Delete extraneous files
-        # TODO: The `download-experimental-build` script copies the npm
-        # packages into the `node_modules` directory. This is a historical
-        # quirk of how the release script works. Let's pretend they
-        # don't exist.
        run: rm -rf ./base-build/node_modules
      - name: Display structure of base-build from origin/main
        run: ls -R base-build
      - 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 for PR
        uses: actions/download-artifact@v4
        with:
@@ -888,11 +752,10 @@ jobs:
          node ./scripts/print-warnings/print-warnings.js > build/__test_utils__/ReactAllWarnings.js
      - name: Display structure of build for PR
        run: ls -R build
-      - run: echo ${{ github.event.inputs.commit_sha != '' && github.event.inputs.commit_sha || github.event.pull_request.head.sha || github.sha }} >> build/COMMIT_SHA
+      - run: echo ${{ github.event.pull_request.head.sha || github.sha }} >> build/COMMIT_SHA
      - run: node ./scripts/tasks/danger
      - name: Archive sizebot results
        uses: actions/upload-artifact@v4
        with:
          name: sizebot-message
          path: sizebot-message.md
-          if-no-files-found: ignore
--- a/.github/workflows/runtime_commit_artifacts.yml
+++ b/.github/workflows/runtime_commit_artifacts.yml
@@ -22,8 +22,6 @@ on:
        default: false
        type: boolean

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -32,40 +30,6 @@ env:
 jobs:
  download_artifacts:
    runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore cached node_modules
-        uses: actions/cache@v4
-        id: node_modules
-        with:
-          path: |
-            **/node_modules
-          key: runtime-release-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'scripts/release/yarn.lock') }}
-      - name: Ensure clean build directory
-        run: rm -rf build
-      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Download artifacts for base revision
-        run: |
-          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }}
-      - name: Display structure of build
-        run: ls -R build
-      - name: Archive build
-        uses: actions/upload-artifact@v4
-        with:
-          name: build
-          path: build/
-          if-no-files-found: error
-
-
-  process_artifacts:
-    runs-on: ubuntu-latest
-    needs: [download_artifacts]
    outputs:
      www_branch_count: ${{ steps.check_branches.outputs.www_branch_count }}
      fbsource_branch_count: ${{ steps.check_branches.outputs.fbsource_branch_count }}
@@ -105,11 +69,25 @@ jobs:
        run: |
          echo "www_branch_count=$(git ls-remote --heads origin "refs/heads/meta-www" | wc -l)" >> "$GITHUB_OUTPUT"
          echo "fbsource_branch_count=$(git ls-remote --heads origin "refs/heads/meta-fbsource" | wc -l)" >> "$GITHUB_OUTPUT"
-      - name: Restore downloaded build
-        uses: actions/download-artifact@v4
+      - uses: actions/setup-node@v4
        with:
-          name: build
-          path: build
+          node-version-file: '.nvmrc'
+          cache: yarn
+          cache-dependency-path: yarn.lock
+      - name: Restore cached node_modules
+        uses: actions/cache@v4
+        id: node_modules
+        with:
+          path: |
+            **/node_modules
+          key: runtime-release-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'scripts/release/yarn.lock') }}
+      - name: Ensure clean build directory
+        run: rm -rf build
+      - run: yarn install --frozen-lockfile
+      - run: yarn --cwd scripts/release install --frozen-lockfile
+      - name: Download artifacts for base revision
+        run: |
+          GH_TOKEN=${{ github.token }} scripts/release/download-experimental-build.js --commit=${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }}
      - name: Display structure of build
        run: ls -R build
      - name: Strip @license from eslint plugin and react-refresh
@@ -132,9 +110,9 @@ jobs:
          mkdir ./compiled/facebook-www/__test_utils__
          mv build/__test_utils__/ReactAllWarnings.js ./compiled/facebook-www/__test_utils__/ReactAllWarnings.js

-          # Copy eslint-plugin-react-hooks
+          # Move eslint-plugin-react-hooks into eslint-plugin-react-hooks
          mkdir ./compiled/eslint-plugin-react-hooks
-          cp build/oss-experimental/eslint-plugin-react-hooks/cjs/eslint-plugin-react-hooks.development.js \
+          mv build/oss-experimental/eslint-plugin-react-hooks/cjs/eslint-plugin-react-hooks.development.js \
            ./compiled/eslint-plugin-react-hooks/index.js

          # Move unstable_server-external-runtime.js into facebook-www
@@ -167,21 +145,15 @@ jobs:
          rm $RENDERER_FOLDER/ReactFabric-{dev,prod,profiling}.js
          rm $RENDERER_FOLDER/ReactNativeRenderer-{dev,prod,profiling}.js

-          # Copy eslint-plugin-react-hooks
-          # NOTE: This is different from www, here we include the full package
-          #       including package.json to include dependencies in fbsource.
-          mkdir "$BASE_FOLDER/tools"
-          cp -r build/oss-experimental/eslint-plugin-react-hooks "$BASE_FOLDER/tools"
-
          # Move React Native version file
          mv build/facebook-react-native/VERSION_NATIVE_FB ./compiled-rn/VERSION_NATIVE_FB

          ls -R ./compiled-rn
      - name: Add REVISION files
        run: |
-          echo ${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }} >> ./compiled/facebook-www/REVISION
+          echo ${{ github.sha }} >> ./compiled/facebook-www/REVISION
          cp ./compiled/facebook-www/REVISION ./compiled/facebook-www/REVISION_TRANSFORMS
-          echo ${{ inputs.commit_sha || github.event.workflow_run.head_sha || github.sha }} >> ./compiled-rn/facebook-fbsource/xplat/js/react-native-github/Libraries/Renderer/REVISION
+          echo ${{ github.sha}} >> ./compiled-rn/facebook-fbsource/xplat/js/react-native-github/Libraries/Renderer/REVISION
      - name: "Get current version string"
        id: get_current_version
        run: |
@@ -198,20 +170,15 @@ jobs:
        with:
          name: compiled
          path: compiled/
-          if-no-files-found: error
      - uses: actions/upload-artifact@v4
        with:
          name: compiled-rn
          path: compiled-rn/
-          if-no-files-found: error

  commit_www_artifacts:
-    needs: [download_artifacts, process_artifacts]
-    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.process_artifacts.outputs.www_branch_count == '0')
+    needs: download_artifacts
+    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.download_artifacts.outputs.www_branch_count == '0')
    runs-on: ubuntu-latest
-    permissions:
-      # Used to push a commit to builds/facebook-www
-      contents: write
    steps:
      - uses: actions/checkout@v4
        with:
@@ -223,12 +190,12 @@ jobs:
          name: compiled
          path: compiled/
      - name: Revert version changes
-        if: needs.process_artifacts.outputs.last_version_classic != '' && needs.process_artifacts.outputs.last_version_modern != ''
+        if: needs.download_artifacts.outputs.last_version_classic != '' && needs.download_artifacts.outputs.last_version_modern != ''
        env:
-          CURRENT_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.current_version_classic }}
-          CURRENT_VERSION_MODERN: ${{ needs.process_artifacts.outputs.current_version_modern }}
-          LAST_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.last_version_classic }}
-          LAST_VERSION_MODERN: ${{ needs.process_artifacts.outputs.last_version_modern }}
+          CURRENT_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.current_version_classic }}
+          CURRENT_VERSION_MODERN: ${{ needs.download_artifacts.outputs.current_version_modern }}
+          LAST_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.last_version_classic }}
+          LAST_VERSION_MODERN: ${{ needs.download_artifacts.outputs.last_version_modern }}
        run: |
          echo "Reverting $CURRENT_VERSION_CLASSIC to $LAST_VERSION_CLASSIC"
          grep -rl "$CURRENT_VERSION_CLASSIC" ./compiled || echo "No files found with $CURRENT_VERSION_CLASSIC"
@@ -258,12 +225,12 @@ jobs:
            echo "should_commit=false" >> "$GITHUB_OUTPUT"
          fi
      - name: Re-apply version changes
-        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.process_artifacts.outputs.last_version_classic != '' && needs.process_artifacts.outputs.last_version_modern != '')
+        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.download_artifacts.outputs.last_version_classic != '' && needs.download_artifacts.outputs.last_version_modern != '')
        env:
-          CURRENT_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.current_version_classic }}
-          CURRENT_VERSION_MODERN: ${{ needs.process_artifacts.outputs.current_version_modern }}
-          LAST_VERSION_CLASSIC: ${{ needs.process_artifacts.outputs.last_version_classic }}
-          LAST_VERSION_MODERN: ${{ needs.process_artifacts.outputs.last_version_modern }}
+          CURRENT_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.current_version_classic }}
+          CURRENT_VERSION_MODERN: ${{ needs.download_artifacts.outputs.current_version_modern }}
+          LAST_VERSION_CLASSIC: ${{ needs.download_artifacts.outputs.last_version_classic }}
+          LAST_VERSION_MODERN: ${{ needs.download_artifacts.outputs.last_version_modern }}
        run: |
          echo "Re-applying $LAST_VERSION_CLASSIC to $CURRENT_VERSION_CLASSIC"
          grep -rl "$LAST_VERSION_CLASSIC" ./compiled || echo "No files found with $LAST_VERSION_CLASSIC"
@@ -277,8 +244,8 @@ jobs:
      - name: Will commit these changes
        if: inputs.force == true || steps.check_should_commit.outputs.should_commit == 'true'
        run: |
-          git add .
-          git status
+          echo ":"
+          git status -u
      - name: Check commit message
        if: inputs.dry_run
        run: |
@@ -297,11 +264,8 @@ jobs:
        run: git push

  commit_fbsource_artifacts:
-    needs: [download_artifacts, process_artifacts]
-    permissions:
-      # Used to push a commit to builds/facebook-fbsource
-      contents: write
-    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.process_artifacts.outputs.fbsource_branch_count == '0')
+    needs: download_artifacts
+    if: inputs.force == true || (github.ref == 'refs/heads/main' && needs.download_artifacts.outputs.fbsource_branch_count == '0')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
@@ -314,10 +278,10 @@ jobs:
          name: compiled-rn
          path: compiled-rn/
      - name: Revert version changes
-        if: needs.process_artifacts.outputs.last_version_rn != ''
+        if: needs.download_artifacts.outputs.last_version_rn != ''
        env:
-          CURRENT_VERSION: ${{ needs.process_artifacts.outputs.current_version_rn }}
-          LAST_VERSION: ${{ needs.process_artifacts.outputs.last_version_rn }}
+          CURRENT_VERSION: ${{ needs.download_artifacts.outputs.current_version_rn }}
+          LAST_VERSION: ${{ needs.download_artifacts.outputs.last_version_rn }}
        run: |
          echo "Reverting $CURRENT_VERSION to $LAST_VERSION"
          grep -rl "$CURRENT_VERSION" ./compiled-rn || echo "No files found with $CURRENT_VERSION"
@@ -332,10 +296,10 @@ jobs:
          git --no-pager diff -U0 --cached | grep '^[+-]' | head -n 100
          echo "===================="
          # Ignore REVISION or lines removing @generated headers.
-          if git diff --cached ':(exclude)*REVISION' ':(exclude)*/eslint-plugin-react-hooks/package.json' | grep -vE "^(@@|diff|index|\-\-\-|\+\+\+|\- \* @generated SignedSource)" | grep "^[+-]" > /dev/null; then
+          if git diff --cached ':(exclude)*REVISION' | grep -vE "^(@@|diff|index|\-\-\-|\+\+\+|\- \* @generated SignedSource)" | grep "^[+-]" > /dev/null; then
            echo "Changes detected"
            echo "===== Changes ====="
-            git --no-pager diff --cached ':(exclude)*REVISION' ':(exclude)*/eslint-plugin-react-hooks/package.json' | grep -vE "^(@@|diff|index|\-\-\-|\+\+\+|\- \* @generated SignedSource)" | grep "^[+-]" | head -n 50
+            git --no-pager diff --cached ':(exclude)*REVISION' | grep -vE "^(@@|diff|index|\-\-\-|\+\+\+|\- \* @generated SignedSource)" | grep "^[+-]" | head -n 50
            echo "==================="
            echo "should_commit=true" >> "$GITHUB_OUTPUT"
          else
@@ -343,10 +307,10 @@ jobs:
            echo "should_commit=false" >> "$GITHUB_OUTPUT"
          fi
      - name: Re-apply version changes
-        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.process_artifacts.outputs.last_version_rn != '')
+        if: inputs.force == true || (steps.check_should_commit.outputs.should_commit == 'true' && needs.download_artifacts.outputs.last_version_rn != '')
        env:
-          CURRENT_VERSION: ${{ needs.process_artifacts.outputs.current_version_rn }}
-          LAST_VERSION: ${{ needs.process_artifacts.outputs.last_version_rn }}
+          CURRENT_VERSION: ${{ needs.download_artifacts.outputs.current_version_rn }}
+          LAST_VERSION: ${{ needs.download_artifacts.outputs.last_version_rn }}
        run: |
          echo "Re-applying $LAST_VERSION to $CURRENT_VERSION"
          grep -rl "$LAST_VERSION" ./compiled-rn || echo "No files found with $LAST_VERSION"
--- a/.github/workflows/runtime_discord_notify.yml
+++ b/.github/workflows/runtime_discord_notify.yml
@@ -7,28 +7,9 @@ on:
      - compiler/**
      - .github/workflows/compiler_**.yml

-permissions: {}
-
 jobs:
-  check_access:
-    if: ${{ github.event.pull_request.draft == false }}
-    runs-on: ubuntu-latest
-    outputs:
-      is_member_or_collaborator: ${{ steps.check_is_member_or_collaborator.outputs.is_member_or_collaborator }}
-    steps:
-      - run: echo ${{ github.event.pull_request.author_association }}
-      - name: Check is member or collaborator
-        id: check_is_member_or_collaborator
-        if: ${{ github.event.pull_request.author_association == 'MEMBER' || github.event.pull_request.author_association == 'COLLABORATOR' }}
-        run: echo "is_member_or_collaborator=true" >> "$GITHUB_OUTPUT"
-
  check_maintainer:
-    if: ${{ needs.check_access.outputs.is_member_or_collaborator == 'true' || needs.check_access.outputs.is_member_or_collaborator == true }}
-    needs: [check_access]
    uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
    with:
      actor: ${{ github.event.pull_request.user.login }}

--- a/.github/workflows/runtime_eslint_plugin_e2e.yml
+++ b/.github/workflows/runtime_eslint_plugin_e2e.yml
@@ -7,8 +7,6 @@ on:
    paths-ignore:
      - compiler/**

-permissions: {}
-
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
@@ -46,20 +44,17 @@ jobs:
        with:
          path: |
            **/node_modules
-          key: runtime-and-compiler-eslint_e2e-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock', 'fixtures/eslint-v*/yarn.lock') }}
+          key: runtime-and-compiler-eslint_e2e-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('yarn.lock', 'compiler/yarn.lock') }}
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn --cwd compiler install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - name: Install fixture dependencies
-        working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
-        run: yarn --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - name: Build plugin
        working-directory: fixtures/eslint-v${{ matrix.eslint_major }}
        run: node build.mjs
+      - name: Install fixture dependencies
+        working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
+        run: yarn --frozen-lockfile
      - name: Run lint test
        working-directory: ./fixtures/eslint-v${{ matrix.eslint_major }}
        run: yarn lint
--- a/.github/workflows/runtime_fuzz_tests.yml
+++ b/.github/workflows/runtime_fuzz_tests.yml
@@ -8,8 +8,6 @@ on:
      - main
  workflow_dispatch:

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles

--- a/.github/workflows/runtime_prereleases.yml
+++ b/.github/workflows/runtime_prereleases.yml
@@ -13,45 +13,21 @@ on:
      dist_tag:
        required: true
        type: string
-      enableFailureNotification:
-        description: 'Whether to notify the team on Discord when the release fails. Useful if this workflow is called from an automation.'
-        required: false
-        type: boolean
-      only_packages:
-        description: Packages to publish (space separated)
-        type: string
-      skip_packages:
-        description: Packages to NOT publish (space separated)
-        type: string
-      dry:
-        required: true
-        description: Dry run instead of publish?
-        type: boolean
-        default: true
    secrets:
-      DISCORD_WEBHOOK_URL:
-        description: 'Discord webhook URL to notify on failure. Only required if enableFailureNotification is true.'
-        required: false
-      GH_TOKEN:
-        required: true
      NPM_TOKEN:
        required: true

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

 jobs:
  publish_prerelease:
    name: Publish prelease (${{ inputs.release_channel }}) ${{ inputs.commit_sha }} @${{ inputs.dist_tag }}
    runs-on: ubuntu-latest
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
@@ -69,44 +45,8 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
-      - run: cp ./scripts/release/ci-npmrc ~/.npmrc
      - run: |
-          GH_TOKEN=${{ secrets.GH_TOKEN }} scripts/release/prepare-release-from-ci.js --skipTests -r ${{ inputs.release_channel }} --commit=${{ inputs.commit_sha }}
-      - name: Check prepared files
-        run: ls -R build/node_modules
-      - if: '${{ inputs.only_packages }}'
-        name: 'Publish ${{ inputs.only_packages }}'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --skipTests \
-            --tags=${{ inputs.dist_tag }} \
-            --onlyPackages=${{ inputs.only_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry' || '' }}
-      - if: '${{ inputs.skip_packages }}'
-        name: 'Publish all packages EXCEPT ${{ inputs.skip_packages }}'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --skipTests \
-            --tags=${{ inputs.dist_tag }} \
-            --skipPackages=${{ inputs.skip_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry' || '' }}
-      - if: '${{ !(inputs.skip_packages && inputs.only_packages) }}'
-        name: 'Publish all packages'
-        run: |
-          scripts/release/publish.js \
-            --ci \
-            --tags=${{ inputs.dist_tag }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry' || '' }}
-      - name: Notify Discord on failure
-        if: failure() && inputs.enableFailureNotification == true
-        uses: tsickert/discord-webhook@86dc739f3f165f16dadc5666051c367efa1692f4
-        with:
-          webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
-          embed-author-name: "GitHub Actions"
-          embed-title: '[Runtime] Publish of ${{ inputs.release_channel }}@${{ inputs.dist_tag}} release failed'
-          embed-url: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}/attempts/${{ github.run_attempt }}
+          scripts/release/prepare-release-from-ci.js --skipTests -r ${{ inputs.release_channel }} --commit=${{ inputs.commit_sha }}
+          cp ./scripts/release/ci-npmrc ~/.npmrc
+          scripts/release/publish.js --ci --tags ${{ inputs.dist_tag }}
--- a/.github/workflows/runtime_prereleases_manual.yml
+++ b/.github/workflows/runtime_prereleases_manual.yml
@@ -5,57 +5,15 @@ on:
    inputs:
      prerelease_commit_sha:
        required: true
-      only_packages:
-        description: Packages to publish (space separated)
-        type: string
-      skip_packages:
-        description: Packages to NOT publish (space separated)
-        type: string
-      dry:
-        required: true
-        description: Dry run instead of publish?
-        type: boolean
-        default: true
-      experimental_only:
-        type: boolean
-        description: Only publish to the experimental tag
-        default: false
-      force_notify:
-        description: Force a Discord notification?
-        type: boolean
-        default: false
-
-permissions: {}

 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles

 jobs:
-  notify:
-    if: ${{ inputs.force_notify || inputs.dry == false || inputs.dry == 'false' }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Discord Webhook Action
-        uses: tsickert/discord-webhook@86dc739f3f165f16dadc5666051c367efa1692f4
-        with:
-          webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
-          embed-author-name: ${{ github.event.sender.login }}
-          embed-author-url: ${{ github.event.sender.html_url }}
-          embed-author-icon-url: ${{ github.event.sender.avatar_url }}
-          embed-title: "⚠️ Publishing ${{ inputs.experimental_only && 'EXPERIMENTAL' || 'CANARY & EXPERIMENTAL' }} release ${{ (inputs.dry && ' (dry run)') || '' }}"
-          embed-description: |
-            ```json
-            ${{ toJson(inputs) }}
-            ```
-          embed-url: https://github.com/facebook/react/actions/runs/${{ github.run_id }}

  publish_prerelease_canary:
-    if: ${{ !inputs.experimental_only }}
    name: Publish to Canary channel
    uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    with:
      commit_sha: ${{ inputs.prerelease_commit_sha }}
      release_channel: stable
@@ -70,33 +28,20 @@ jobs:
      # downstream consumers might still expect that tag. We can remove this
      # after some time has elapsed and the change has been communicated.
      dist_tag: canary,next
-      only_packages: ${{ inputs.only_packages }}
-      skip_packages: ${{ inputs.skip_packages }}
-      dry: ${{ inputs.dry }}
    secrets:
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  publish_prerelease_experimental:
    name: Publish to Experimental channel
    uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    # NOTE: Intentionally running these jobs sequentially because npm
    # will sometimes fail if you try to concurrently publish two
    # different versions of the same package, even if they use different
    # dist tags.
    needs: publish_prerelease_canary
-    # Ensures the job runs even if canary is skipped
-    if: always()
    with:
      commit_sha: ${{ inputs.prerelease_commit_sha }}
      release_channel: experimental
      dist_tag: experimental
-      only_packages: ${{ inputs.only_packages }}
-      skip_packages: ${{ inputs.skip_packages }}
-      dry: ${{ inputs.dry }}
    secrets:
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/runtime_prereleases_nightly.yml
+++ b/.github/workflows/runtime_prereleases_nightly.yml
@@ -5,8 +5,6 @@ on:
    # At 10 minutes past 16:00 on Mon, Tue, Wed, Thu, and Fri
    - cron: 10 16 * * 1,2,3,4,5

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles

@@ -14,26 +12,16 @@ jobs:
  publish_prerelease_canary:
    name: Publish to Canary channel
    uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    with:
      commit_sha: ${{ github.sha }}
      release_channel: stable
      dist_tag: canary,next
-      enableFailureNotification: true
-      dry: false
    secrets:
-      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  publish_prerelease_experimental:
    name: Publish to Experimental channel
    uses: facebook/react/.github/workflows/runtime_prereleases.yml@main
-    permissions:
-      # We use github.token to download the build artifact from a previous runtime_build_and_test.yml run
-      actions: read
    # NOTE: Intentionally running these jobs sequentially because npm
    # will sometimes fail if you try to concurrently publish two
    # different versions of the same package, even if they use different
@@ -43,9 +31,5 @@ jobs:
      commit_sha: ${{ github.sha }}
      release_channel: experimental
      dist_tag: experimental
-      enableFailureNotification: true
-      dry: false
    secrets:
-      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/runtime_releases_from_npm_manual.yml
+++ b/.github/workflows/runtime_releases_from_npm_manual.yml
@@ -31,12 +31,11 @@ on:
        type: boolean
        default: false

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+  GH_TOKEN: ${{ github.token }}
  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

 jobs:
@@ -78,9 +77,7 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn --cwd scripts/release install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: cp ./scripts/release/ci-npmrc ~/.npmrc
      - if: '${{ inputs.only_packages }}'
        name: 'Prepare ${{ inputs.only_packages }} from NPM'
@@ -110,7 +107,7 @@ jobs:
            --tags=${{ inputs.tags }} \
            --publishVersion=${{ inputs.version_to_publish }} \
            --onlyPackages=${{ inputs.only_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry' || '' }}
+            ${{ inputs.dry && '--dry'}}
      - if: '${{ inputs.skip_packages }}'
        name: 'Publish all packages EXCEPT ${{ inputs.skip_packages }}'
        run: |
@@ -119,7 +116,7 @@ jobs:
            --tags=${{ inputs.tags }} \
            --publishVersion=${{ inputs.version_to_publish }} \
            --skipPackages=${{ inputs.skip_packages }} ${{ (inputs.dry && '') || '\'}}
-            ${{ inputs.dry && '--dry' || '' }}
+            ${{ inputs.dry && '--dry'}}
      - name: Archive released package for debugging
        uses: actions/upload-artifact@v4
        with:
--- a/.github/workflows/shared_check_maintainer.yml
+++ b/.github/workflows/shared_check_maintainer.yml
@@ -6,12 +6,14 @@ on:
      actor:
        required: true
        type: string
+      is_remote:
+        required: false
+        type: boolean
+        default: false
    outputs:
      is_core_team:
        value: ${{ jobs.check_maintainer.outputs.is_core_team }}

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -20,12 +22,10 @@ env:
 jobs:
  check_maintainer:
    runs-on: ubuntu-latest
-    permissions:
-      # We fetch the contents of the MAINTAINERS file
-      contents: read
    outputs:
      is_core_team: ${{ steps.check_if_actor_is_maintainer.outputs.result }}
    steps:
+      - uses: actions/checkout@v4
      - name: Check if actor is maintainer
        id: check_if_actor_is_maintainer
        uses: actions/github-script@v7
@@ -33,20 +33,33 @@ jobs:
          script: |
            const fs = require('fs');
            const actor = '${{ inputs.actor }}';
-            const res = await github.rest.repos.getContent({
-              owner: 'facebook',
-              repo: 'react',
-              path: 'MAINTAINERS',
-              ref: 'main',
-              headers: { Accept: 'application/vnd.github+json' }
-            });
-            if (res.status !== 200) {
-              console.error(res);
-              throw new Error('Unable to fetch MAINTAINERS file');
+            let isRemote = ${{ inputs.is_remote }};
+            if (typeof isRemote === 'string') {
+              isRemote = isRemote === 'true';
            }
-            content = Buffer.from(res.data.content, 'base64').toString();
-            if (content == null || typeof content !== 'string') {
-              throw new Error('Unable to retrieve MAINTAINERS file');
+            if (typeof isRemote !== 'boolean') {
+              throw new Error(`Invalid \`isRemote\` input. Expected a boolean, got: ${isRemote}`);
+            }
+
+            let content = null;
+            if (isRemote === true) {
+              const res = await github.rest.repos.getContent({
+                owner: 'facebook',
+                repo: 'react',
+                path: 'MAINTAINERS',
+                ref: 'main',
+                headers: { Accept: 'application/vnd.github+json' }
+              });
+              if (res.status !== 200) {
+                console.error(res);
+                throw new Error('Unable to fetch MAINTAINERS file');
+              }
+              content = Buffer.from(res.data.content, 'base64').toString();
+            } else {
+              content = await fs.readFileSync('./MAINTAINERS', { encoding: 'utf8' });
+            }
+            if (content === null) {
+              throw new Error('Unable to retrieve local or http MAINTAINERS file');
            }

            const maintainers = new Set(content.split('\n'));
--- a/.github/workflows/shared_cleanup_merged_branch_caches.yml
+++ b/.github/workflows/shared_cleanup_merged_branch_caches.yml
@@ -1,17 +1,11 @@
 # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#force-deletion-of-caches-overriding-default-cache-eviction-policy

-name: (Shared) Cleanup Merged Branch Caches
+name: (Shared) Cleanup Branch Caches
 on:
  pull_request:
    types:
      - closed
  workflow_dispatch:
-    inputs:
-      pr_number:
-        required: true
-        type: string
-
-permissions: {}

 jobs:
  cleanup:
@@ -29,13 +23,13 @@ jobs:

          ## Setting this to not fail the workflow while deleting cache keys.
          set +e
+          echo "Deleting caches..."
          for cacheKey in $cacheKeysForPR
          do
              gh cache delete $cacheKey
-              echo "Deleting $cacheKey"
          done
          echo "Done"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GH_REPO: ${{ github.repository }}
-          BRANCH: refs/pull/${{ inputs.pr_number || github.event.pull_request.number }}/merge
+          BRANCH: refs/pull/${{ github.event.pull_request.number }}/merge
--- a/.github/workflows/shared_cleanup_stale_branch_caches.yml
+++ b/.github/workflows/shared_cleanup_stale_branch_caches.yml
@@ -1,36 +0,0 @@
-# https://github.com/actions/cache/blob/main/tips-and-workarounds.md#force-deletion-of-caches-overriding-default-cache-eviction-policy
-
-name: (Shared) Cleanup Stale Branch Caches
-on:
-  schedule:
-    # Every 6 hours
-    - cron: 0 */6 * * *
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  cleanup:
-    runs-on: ubuntu-latest
-    permissions:
-      # `actions:write` permission is required to delete caches
-      #   See also: https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28#delete-a-github-actions-cache-for-a-repository-using-a-cache-id
-      actions: write
-      contents: read
-    steps:
-      - name: Cleanup
-        run: |
-          echo "Fetching list of cache keys"
-          cacheKeysForPR=$(gh cache list --limit 100 --json id,ref --jq '.[] | select(.ref != "refs/heads/main") | .id')
-
-          ## Setting this to not fail the workflow while deleting cache keys.
-          set +e
-          for cacheKey in $cacheKeysForPR
-          do
-              gh cache delete $cacheKey
-              echo "Deleting $cacheKey"
-          done
-          echo "Done"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
--- a/.github/workflows/shared_close_direct_sync_branch_prs.yml
+++ b/.github/workflows/shared_close_direct_sync_branch_prs.yml
@@ -5,8 +5,6 @@ on:
    branches:
      - 'builds/facebook-**'

-permissions: {}
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
  # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#cache-segment-restore-timeout
@@ -15,10 +13,6 @@ env:
 jobs:
  close_pr:
    runs-on: ubuntu-latest
-    permissions:
-      # Used to create a review and close PRs
-      pull-requests: write
-      contents: write
    steps:
      - name: Close PR
        uses: actions/github-script@v7
--- a/.github/workflows/shared_label_core_team_prs.yml
+++ b/.github/workflows/shared_label_core_team_prs.yml
@@ -2,9 +2,6 @@ name: (Shared) Label Core Team PRs

 on:
  pull_request_target:
-    types: [opened]
-
-permissions: {}

 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles
@@ -12,24 +9,8 @@ env:
  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1

 jobs:
-  check_access:
-    runs-on: ubuntu-latest
-    outputs:
-      is_member_or_collaborator: ${{ steps.check_is_member_or_collaborator.outputs.is_member_or_collaborator }}
-    steps:
-      - run: echo ${{ github.event.pull_request.author_association }}
-      - name: Check is member or collaborator
-        id: check_is_member_or_collaborator
-        if: ${{ github.event.pull_request.author_association == 'MEMBER' || github.event.pull_request.author_association == 'COLLABORATOR' }}
-        run: echo "is_member_or_collaborator=true" >> "$GITHUB_OUTPUT"
-
  check_maintainer:
-    if: ${{ needs.check_access.outputs.is_member_or_collaborator == 'true' || needs.check_access.outputs.is_member_or_collaborator == true }}
-    needs: [check_access]
    uses: facebook/react/.github/workflows/shared_check_maintainer.yml@main
-    permissions:
-      # Used by check_maintainer
-      contents: read
    with:
      actor: ${{ github.event.pull_request.user.login }}

@@ -37,11 +18,6 @@ jobs:
    if: ${{ needs.check_maintainer.outputs.is_core_team == 'true' }}
    runs-on: ubuntu-latest
    needs: check_maintainer
-    permissions:
-      # Used to add labels on issues
-      issues: write
-      # Used to add labels on PRs
-      pull-requests: write
    steps:
      - name: Label PR as React Core Team
        uses: actions/github-script@v7
--- a/.github/workflows/shared_lint.yml
+++ b/.github/workflows/shared_lint.yml
@@ -5,8 +5,6 @@ on:
    branches: [main]
  pull_request:

-permissions: {}
-
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
@@ -29,7 +27,6 @@ jobs:
          cache-dependency-path: yarn.lock
      - name: Restore cached node_modules
        uses: actions/cache@v4
-        id: node_modules
        with:
          path: |
            **/node_modules
@@ -37,7 +34,6 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: yarn prettier-check

  eslint:
@@ -52,7 +48,6 @@ jobs:
          cache-dependency-path: yarn.lock
      - name: Restore cached node_modules
        uses: actions/cache@v4
-        id: node_modules
        with:
          path: |
            **/node_modules
@@ -60,7 +55,6 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: node ./scripts/tasks/eslint

  check_license:
@@ -75,7 +69,6 @@ jobs:
          cache-dependency-path: yarn.lock
      - name: Restore cached node_modules
        uses: actions/cache@v4
-        id: node_modules
        with:
          path: |
            **/node_modules
@@ -83,7 +76,6 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: ./scripts/ci/check_license.sh

  test_print_warnings:
@@ -98,7 +90,6 @@ jobs:
          cache-dependency-path: yarn.lock
      - name: Restore cached node_modules
        uses: actions/cache@v4
-        id: node_modules
        with:
          path: |
            **/node_modules
@@ -106,5 +97,4 @@ jobs:
      - name: Ensure clean build directory
        run: rm -rf build
      - run: yarn install --frozen-lockfile
-        if: steps.node_modules.outputs.cache-hit != 'true'
      - run: ./scripts/ci/test_print_warnings.sh
--- a/.github/workflows/shared_stale.yml
+++ b/.github/workflows/shared_stale.yml
@@ -6,11 +6,6 @@ on:
    - cron: '0 * * * *'
  workflow_dispatch:

-permissions:
-  # https://github.com/actions/stale/tree/v9/?tab=readme-ov-file#recommended-permissions
-  issues: write
-  pull-requests: write
-
 env:
  TZ: /usr/share/zoneinfo/America/Los_Angeles

--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-v20.19.0
+v18.20.1
--- a/.prettierrc.js
+++ b/.prettierrc.js
@@ -3,12 +3,13 @@
 const {esNextPaths} = require('./scripts/shared/pathsByLanguageVersion');

 module.exports = {
+  plugins: ['prettier-plugin-hermes-parser'],
  bracketSpacing: false,
  singleQuote: true,
  bracketSameLine: true,
  trailingComma: 'es5',
  printWidth: 80,
-  parser: 'flow',
+  parser: 'hermes',
  arrowParens: 'avoid',
  overrides: [
    {
--- a/CHANGELOG-canary.md
+++ b/CHANGELOG-canary.md
@@ -0,0 +1,18 @@
+## March 22, 2024 (18.3.0-canary-670811593-20240322)
+
+## React
+- Added `useActionState` to replace `useFormState` and added `pending` value ([#28491](https://github.com/facebook/react/pull/28491)).
+
+## October 5, 2023 (18.3.0-canary-546178f91-20231005)
+
+### React
+
+- Added support for async functions to be passed to `startTransition`. 
+- `useTransition` now triggers the nearest error boundary instead of a global error.
+- Added `useOptimistic`, a new Hook for handling optimistic UI updates. It optimistically updates the UI before receiving confirmation from a server or external source.
+
+### React DOM
+
+- Added support for passing async functions to the `action` prop on `<form>`. When the function passed to `action` is marked with [`'use server'`](https://react.dev/reference/react/use-server), the form is [progressively enhanced](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement).
+- Added `useFormStatus`, a new Hook for checking the submission state of a form.
+- Added `useFormState`, a new Hook for updating state upon form submission. When the function passed to `useFormState` is marked with [`'use server'`](https://react.dev/reference/react/use-server), the update is [progressively enhanced](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement).
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,55 +1,3 @@
-## 19.1.1 (July 28, 2025)
-
-### React
-* Fixed Owner Stacks to work with ES2015 function.name semantics ([#33680](https://github.com/facebook/react/pull/33680) by @hoxyq)
-
-## 19.1.0 (March 28, 2025)
-
-### Owner Stack
-
-An Owner Stack is a string representing the components that are directly responsible for rendering a particular component. You can log Owner Stacks when debugging or use Owner Stacks to enhance error overlays or other development tools. Owner Stacks are only available in development builds. Component Stacks in production are unchanged.
-
-* An Owner Stack is a development-only stack trace that helps identify which components are responsible for rendering a particular component. An Owner Stack is distinct from a Component Stacks, which shows the hierarchy of components leading to an error.
-* The [captureOwnerStack API](https://react.dev/reference/react/captureOwnerStack) is only available in development mode and returns a Owner Stack, if available. The API can be used to enhance error overlays or log component relationships when debugging. [#29923](https://github.com/facebook/react/pull/29923), [#32353](https://github.com/facebook/react/pull/32353), [#30306](https://github.com/facebook/react/pull/30306),
-[#32538](https://github.com/facebook/react/pull/32538), [#32529](https://github.com/facebook/react/pull/32529), [#32538](https://github.com/facebook/react/pull/32538)
-
-### React
-* Enhanced support for Suspense boundaries to be used anywhere, including the client, server, and during hydration. [#32069](https://github.com/facebook/react/pull/32069), [#32163](https://github.com/facebook/react/pull/32163), [#32224](https://github.com/facebook/react/pull/32224), [#32252](https://github.com/facebook/react/pull/32252)
-* Reduced unnecessary client rendering through improved hydration scheduling [#31751](https://github.com/facebook/react/pull/31751)
-* Increased priority of client rendered Suspense boundaries [#31776](https://github.com/facebook/react/pull/31776)
-* Fixed frozen fallback states by rendering unfinished Suspense boundaries on the client. [#31620](https://github.com/facebook/react/pull/31620)
-* Reduced garbage collection pressure by improving Suspense boundary retries. [#31667](https://github.com/facebook/react/pull/31667)
-* Fixed erroneous “Waiting for Paint” log when the passive effect phase was not delayed [#31526](https://github.com/facebook/react/pull/31526)
-* Fixed a regression causing key warnings for flattened positional children in development mode. [#32117](https://github.com/facebook/react/pull/32117)
-* Updated `useId` to use valid CSS selectors, changing format from `:r123:` to `«r123»`. [#32001](https://github.com/facebook/react/pull/32001)
-* Added a dev-only warning for null/undefined created in useEffect, useInsertionEffect, and useLayoutEffect. [#32355](https://github.com/facebook/react/pull/32355)
-* Fixed a bug where dev-only methods were exported in production builds. React.act is no longer available in production builds. [#32200](https://github.com/facebook/react/pull/32200)
-* Improved consistency across prod and dev to improve compatibility with Google Closure Compiler and bindings [#31808](https://github.com/facebook/react/pull/31808)
-* Improve passive effect scheduling for consistent task yielding. [#31785](https://github.com/facebook/react/pull/31785)
-* Fixed asserts in React Native when passChildrenWhenCloningPersistedNodes is enabled for OffscreenComponent rendering. [#32528](https://github.com/facebook/react/pull/32528)
-* Fixed component name resolution for Portal [#32640](https://github.com/facebook/react/pull/32640)
-* Added support for beforetoggle and toggle events on the dialog element. [#32479](https://github.com/facebook/react/pull/32479)
-
-### React DOM
-* Fixed double warning when the `href` attribute is an empty string [#31783](https://github.com/facebook/react/pull/31783)
- * Fixed an edge case where `getHoistableRoot()` didn’t work properly when the container was a Document [#32321](https://github.com/facebook/react/pull/32321)
-* Removed support for using HTML comments (e.g. `<!-- -->`) as a DOM container. [#32250](https://github.com/facebook/react/pull/32250)
-* Added support for `<script>` and `<template>` tags to be nested within `<select>` tags. [#31837](https://github.com/facebook/react/pull/31837)
-* Fixed responsive images to be preloaded as HTML instead of headers [#32445](https://github.com/facebook/react/pull/32445)
-
-### use-sync-external-store
-* Added `exports` field to `package.json` for `use-sync-external-store` to support various entrypoints. [#25231](https://github.com/facebook/react/pull/25231)
-
-### React Server Components
-* Added `unstable_prerender`, a new experimental API for prerendering React Server Components on the server [#31724](https://github.com/facebook/react/pull/31724)
-* Fixed an issue where streams would hang when receiving new chunks after a global error [#31840](https://github.com/facebook/react/pull/31840), [#31851](https://github.com/facebook/react/pull/31851)
-* Fixed an issue where pending chunks were counted twice. [#31833](https://github.com/facebook/react/pull/31833)
-* Added support for streaming in edge environments [#31852](https://github.com/facebook/react/pull/31852)
-* Added support for sending custom error names from a server so that they are available in the client for console replaying. [#32116](https://github.com/facebook/react/pull/32116)
-* Updated the server component wire format to remove IDs for hints and console.log because they have no return value [#31671](https://github.com/facebook/react/pull/31671)
-* 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.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/ReactVersions.js
+++ b/ReactVersions.js
@@ -18,7 +18,7 @@
 //
 //   0.0.0-experimental-241c4467e-20200129

-const ReactVersion = '19.2.0';
+const ReactVersion = '19.1.0';

 // The label used by the @canary channel. Represents the upcoming release's
 // stability. Most of the time, this will be "canary", but we may temporarily
@@ -33,7 +33,6 @@ const canaryChannelLabel = 'canary';
 const rcNumber = 0;

 const stablePackages = {
-  'eslint-plugin-react-hooks': '6.1.0',
  'jest-react': '0.17.0',
  react: ReactVersion,
  'react-art': ReactVersion,
@@ -42,12 +41,12 @@ const stablePackages = {
  'react-server-dom-turbopack': ReactVersion,
  'react-server-dom-parcel': ReactVersion,
  'react-is': ReactVersion,
-  'react-reconciler': '0.33.0',
-  'react-refresh': '0.18.0',
+  'react-reconciler': '0.32.0',
+  'react-refresh': '0.17.0',
  'react-test-renderer': ReactVersion,
-  'use-subscription': '1.12.0',
-  'use-sync-external-store': '1.6.0',
-  scheduler: '0.27.0',
+  'use-subscription': '1.11.0',
+  'use-sync-external-store': '1.5.0',
+  scheduler: '0.26.0',
 };

 // These packages do not exist in the @canary or @latest channel, only
--- a/babel.config-react-compiler.js
+++ b/babel.config-react-compiler.js
@@ -1,19 +0,0 @@
-'use strict';
-
-/**
- * HACK: @poteto React Compiler inlines Zod in its build artifact. Zod spreads values passed to .map
- * which causes issues in @babel/plugin-transform-spread in loose mode, as it will result in
- * {undefined: undefined} which fails to parse.
- *
- * [@babel/plugin-transform-block-scoping', {throwIfClosureRequired: true}] also causes issues with
- * the built version of the compiler. The minimal set of plugins needed for this file is reexported
- * from babel.config-ts.
- *
- * I will remove this hack later when we move eslint-plugin-react-hooks into the compiler directory.
- **/
-
-const baseConfig = require('./babel.config-ts');
-
-module.exports = {
-  plugins: baseConfig.plugins,
-};
--- a/babel.config-ts.js
+++ b/babel.config-ts.js
@@ -8,7 +8,6 @@ module.exports = {
    '@babel/plugin-syntax-jsx',
    '@babel/plugin-transform-flow-strip-types',
    ['@babel/plugin-transform-class-properties', {loose: true}],
-    ['@babel/plugin-transform-private-methods', {loose: true}],
    '@babel/plugin-transform-classes',
  ],
  presets: [
--- a/compiler/.gitignore
+++ b/compiler/.gitignore
@@ -1,14 +1,28 @@
 .DS_Store
 .spr.yml

+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
 node_modules
 .watchmanconfig
 .watchman-cookie-*
 dist
 .vscode
 !packages/playground/.vscode
+.spr.yml
 testfilter.txt

+bundle-oss.sh
+
 # forgive
 *.vsix
 .vscode-test
--- a/compiler/CHANGELOG.md
+++ b/compiler/CHANGELOG.md
@@ -1,65 +0,0 @@
-## 19.1.0-rc.2 (May 14, 2025)
-
-## babel-plugin-react-compiler
-
-* Fix for string attribute values with emoji [#33096](https://github.com/facebook/react/pull/33096) by [@josephsavona](https://github.com/josephsavona)
-
-## 19.1.0-rc.1 (April 21, 2025)
-
-## eslint-plugin-react-hooks
-* Temporarily disable ref access in render validation [#32839](https://github.com/facebook/react/pull/32839) by [@poteto](https://github.com/poteto)
-* Fix type error with recommended config [#32666](https://github.com/facebook/react/pull/32666) by [@niklasholm](https://github.com/niklasholm)
-* Merge rule from eslint-plugin-react-compiler into `react-hooks` plugin [#32416](https://github.com/facebook/react/pull/32416) by [@michaelfaith](https://github.com/michaelfaith)
-* Add dev dependencies for typescript migration [#32279](https://github.com/facebook/react/pull/32279) by [@michaelfaith](https://github.com/michaelfaith)
-* Support v9 context api [#32045](https://github.com/facebook/react/pull/32045) by [@michaelfaith](https://github.com/michaelfaith)
-* Support eslint 8+ flat plugin syntax out of the box for eslint-plugin-react-compiler [#32120](https://github.com/facebook/react/pull/32120) by [@orta](https://github.com/orta)
-
-## babel-plugin-react-compiler
-* Support satisfies operator [#32742](https://github.com/facebook/react/pull/32742) by [@rodrigofariow](https://github.com/rodrigofariow)
-* Fix inferEffectDependencies lint false positives [#32769](https://github.com/facebook/react/pull/32769) by [@mofeiZ](https://github.com/mofeiZ)
-* Fix hoisting of let declarations [#32724](https://github.com/facebook/react/pull/32724) by [@mofeiZ](https://github.com/mofeiZ)
-* Avoid failing builds when import specifiers conflict or shadow vars [#32663](https://github.com/facebook/react/pull/32663) by [@mofeiZ](https://github.com/mofeiZ)
-* Optimize components declared with arrow function and implicit return and `compilationMode: 'infer'` [#31792](https://github.com/facebook/react/pull/31792) by [@dimaMachina](https://github.com/dimaMachina)
-* Validate static components [#32683](https://github.com/facebook/react/pull/32683) by [@josephsavona](https://github.com/josephsavona)
-* Hoist dependencies from functions more conservatively [#32616](https://github.com/facebook/react/pull/32616) by [@mofeiZ](https://github.com/mofeiZ)
-* Implement NumericLiteral as ObjectPropertyKey [#31791](https://github.com/facebook/react/pull/31791) by [@dimaMachina](https://github.com/dimaMachina)
-* Avoid bailouts when inserting gating [#32598](https://github.com/facebook/react/pull/32598) by [@mofeiZ](https://github.com/mofeiZ)
-* Stop bailing out early for hoisted gated functions [#32597](https://github.com/facebook/react/pull/32597) by [@mofeiZ](https://github.com/mofeiZ)
-* Add shape for Array.from [#32522](https://github.com/facebook/react/pull/32522) by [@mofeiZ](https://github.com/mofeiZ)
-* Patch array and argument spread mutability [#32521](https://github.com/facebook/react/pull/32521) by [@mofeiZ](https://github.com/mofeiZ)
-* Make CompilerError compatible with reflection [#32539](https://github.com/facebook/react/pull/32539) by [@poteto](https://github.com/poteto)
-* Add simple walltime measurement [#32331](https://github.com/facebook/react/pull/32331) by [@poteto](https://github.com/poteto)
-* Improve error messages for unhandled terminal and instruction kinds [#32324](https://github.com/facebook/react/pull/32324) by [@inottn](https://github.com/inottn)
-* Handle TSInstantiationExpression in lowerExpression [#32302](https://github.com/facebook/react/pull/32302) by [@inottn](https://github.com/inottn)
-* Fix invalid Array.map type [#32095](https://github.com/facebook/react/pull/32095) by [@mofeiZ](https://github.com/mofeiZ)
-* Patch for JSX escape sequences in @babel/generator [#32131](https://github.com/facebook/react/pull/32131) by [@mofeiZ](https://github.com/mofeiZ)
-* `JSXText` emits incorrect with bracket [#32138](https://github.com/facebook/react/pull/32138) by [@himself65](https://github.com/himself65)
-* Validation against calling impure functions [#31960](https://github.com/facebook/react/pull/31960) by [@josephsavona](https://github.com/josephsavona)
-* Always target node [#32091](https://github.com/facebook/react/pull/32091) by [@poteto](https://github.com/poteto)
-* Patch compilationMode:infer object method edge case [#32055](https://github.com/facebook/react/pull/32055) by [@mofeiZ](https://github.com/mofeiZ)
-* Generate ts defs [#31994](https://github.com/facebook/react/pull/31994) by [@poteto](https://github.com/poteto)
-* Relax react peer dep requirement [#31915](https://github.com/facebook/react/pull/31915) by [@poteto](https://github.com/poteto)
-* Allow type cast expressions with refs [#31871](https://github.com/facebook/react/pull/31871) by [@josephsavona](https://github.com/josephsavona)
-* Add shape for global Object.keys [#31583](https://github.com/facebook/react/pull/31583) by [@mofeiZ](https://github.com/mofeiZ)
-* Optimize method calls w props receiver [#31775](https://github.com/facebook/react/pull/31775) by [@josephsavona](https://github.com/josephsavona)
-* Fix dropped ref with spread props in InlineJsxTransform [#31726](https://github.com/facebook/react/pull/31726) by [@jackpope](https://github.com/jackpope)
-* Support for non-declatation for in/of iterators [#31710](https://github.com/facebook/react/pull/31710) by [@mvitousek](https://github.com/mvitousek)
-* Support for context variable loop iterators [#31709](https://github.com/facebook/react/pull/31709) by [@mvitousek](https://github.com/mvitousek)
-* Replace deprecated dependency in `eslint-plugin-react-compiler` [#31629](https://github.com/facebook/react/pull/31629) by [@rakleed](https://github.com/rakleed)
-* Support enableRefAsProp in jsx transform [#31558](https://github.com/facebook/react/pull/31558) by [@jackpope](https://github.com/jackpope)
-* Fix: ref.current now correctly reactive [#31521](https://github.com/facebook/react/pull/31521) by [@mofeiZ](https://github.com/mofeiZ)
-* Outline JSX with non-jsx children [#31442](https://github.com/facebook/react/pull/31442) by [@gsathya](https://github.com/gsathya)
-* Outline jsx with duplicate attributes [#31441](https://github.com/facebook/react/pull/31441) by [@gsathya](https://github.com/gsathya)
-* Store original and new prop names [#31440](https://github.com/facebook/react/pull/31440) by [@gsathya](https://github.com/gsathya)
-* Stabilize compiler output: sort deps and decls by name [#31362](https://github.com/facebook/react/pull/31362) by [@mofeiZ](https://github.com/mofeiZ)
-* Bugfix for hoistable deps for nested functions [#31345](https://github.com/facebook/react/pull/31345) by [@mofeiZ](https://github.com/mofeiZ)
-* Remove compiler runtime-compat fixture library [#31430](https://github.com/facebook/react/pull/31430) by [@poteto](https://github.com/poteto)
-* Wrap inline jsx transform codegen in conditional [#31267](https://github.com/facebook/react/pull/31267) by [@jackpope](https://github.com/jackpope)
-* Check if local identifier is a hook when resolving globals [#31384](https://github.com/facebook/react/pull/31384) by [@poteto](https://github.com/poteto)
-* Handle member expr as computed property [#31344](https://github.com/facebook/react/pull/31344) by [@gsathya](https://github.com/gsathya)
-* Fix to ref access check to ban ref?.current [#31360](https://github.com/facebook/react/pull/31360) by [@mvitousek](https://github.com/mvitousek)
-* InlineJSXTransform transforms jsx inside function expressions [#31282](https://github.com/facebook/react/pull/31282) by [@josephsavona](https://github.com/josephsavona)
-
-## Other
-* Add shebang to banner [#32225](https://github.com/facebook/react/pull/32225) by [@Jeremy-Hibiki](https://github.com/Jeremy-Hibiki)
-* remove terser from react-compiler-runtime build [#31326](https://github.com/facebook/react/pull/31326) by [@henryqdineen](https://github.com/henryqdineen)
--- a/compiler/apps/playground/tests/e2e/snapshots/page.spec.ts/compilationMode-all-output.txt
+++ b/compiler/apps/playground/tests/e2e/snapshots/page.spec.ts/compilationMode-all-output.txt
@@ -1,5 +1,5 @@
 import { c as _c } from "react/compiler-runtime"; // 
-@compilationMode:"all"
+        @compilationMode(all)
 function nonReactFn() {
   const $ = _c(1);
   let t0;
--- a/compiler/apps/playground/tests/e2e/snapshots/page.spec.ts/compilationMode-infer-output.txt
+++ b/compiler/apps/playground/tests/e2e/snapshots/page.spec.ts/compilationMode-infer-output.txt
@@ -1,4 +1,4 @@
-// @compilationMode:"infer"
+// @compilationMode(infer)
 function nonReactFn() {
   return {};
 }
--- a/compiler/apps/playground/tests/e2e/page.spec.ts
+++ b/compiler/apps/playground/tests/e2e/page.spec.ts
@@ -92,7 +92,7 @@ function useFoo(propVal: {+baz: number}) {
  },
  {
    name: 'compilationMode-infer',
-    input: `// @compilationMode:"infer"
+    input: `// @compilationMode(infer)
 function nonReactFn() {
  return {};
 }
@@ -101,7 +101,7 @@ function nonReactFn() {
  },
  {
    name: 'compilationMode-all',
-    input: `// @compilationMode:"all"
+    input: `// @compilationMode(all)
 function nonReactFn() {
  return {};
 }
--- a/compiler/apps/playground/components/Editor/ConfigEditor.tsx
+++ b/compiler/apps/playground/components/Editor/ConfigEditor.tsx
@@ -1,103 +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 MonacoEditor, {loader, type Monaco} from '@monaco-editor/react';
-import {parseConfigPragmaAsString} from 'babel-plugin-react-compiler';
-import type {editor} from 'monaco-editor';
-import * as monaco from 'monaco-editor';
-import parserBabel from 'prettier/plugins/babel';
-import * as prettierPluginEstree from 'prettier/plugins/estree';
-import * as prettier from 'prettier/standalone';
-import {useState, useEffect} from 'react';
-import {Resizable} from 're-resizable';
-import {useStore} from '../StoreContext';
-import {monacoOptions} from './monacoOptions';
-
-loader.config({monaco});
-
-export default function ConfigEditor(): JSX.Element {
-  const [, setMonaco] = useState<Monaco | null>(null);
-  const store = useStore();
-
-  // Parse string-based override config from pragma comment and format it
-  const [configJavaScript, setConfigJavaScript] = useState('');
-
-  useEffect(() => {
-    const pragma = store.source.substring(0, store.source.indexOf('\n'));
-    const configString = `(${parseConfigPragmaAsString(pragma)})`;
-
-    prettier
-      .format(configString, {
-        semi: true,
-        parser: 'babel-ts',
-        plugins: [parserBabel, prettierPluginEstree],
-      })
-      .then(formatted => {
-        setConfigJavaScript(formatted);
-      })
-      .catch(error => {
-        console.error('Error formatting config:', error);
-        setConfigJavaScript('({})'); // Return empty object if not valid for now
-        //TODO: Add validation and error handling for config
-      });
-    console.log('Config:', configString);
-  }, [store.source]);
-
-  const handleChange: (value: string | undefined) => void = value => {
-    if (!value) return;
-
-    // TODO: Implement sync logic to update pragma comments in the source
-    console.log('Config changed:', value);
-  };
-
-  const handleMount: (
-    _: editor.IStandaloneCodeEditor,
-    monaco: Monaco,
-  ) => void = (_, monaco) => {
-    setMonaco(monaco);
-
-    const uri = monaco.Uri.parse(`file:///config.js`);
-    const model = monaco.editor.getModel(uri);
-    if (model) {
-      model.updateOptions({tabSize: 2});
-    }
-  };
-
-  return (
-    <div className="relative flex flex-col flex-none border-r border-gray-200">
-      <h2 className="p-4 duration-150 ease-in border-b cursor-default border-grey-200 font-light text-secondary">
-        Config Overrides
-      </h2>
-      <Resizable
-        minWidth={300}
-        maxWidth={600}
-        defaultSize={{width: 350, height: 'auto'}}
-        enable={{right: true}}
-        className="!h-[calc(100vh_-_3.5rem_-_4rem)]">
-        <MonacoEditor
-          path={'config.js'}
-          language={'javascript'}
-          value={configJavaScript}
-          onMount={handleMount}
-          onChange={handleChange}
-          options={{
-            ...monacoOptions,
-            readOnly: true,
-            lineNumbers: 'off',
-            folding: false,
-            renderLineHighlight: 'none',
-            scrollBeyondLastLine: false,
-            hideCursorInOverviewRuler: true,
-            overviewRulerBorder: false,
-            overviewRulerLanes: 0,
-            fontSize: 12,
-          }}
-        />
-      </Resizable>
-    </div>
-  );
-}
--- a/compiler/apps/playground/components/Editor/EditorImpl.tsx
+++ b/compiler/apps/playground/components/Editor/EditorImpl.tsx
@@ -11,7 +11,6 @@ import * as t from '@babel/types';
 import BabelPluginReactCompiler, {
  CompilerError,
  CompilerErrorDetail,
-  CompilerDiagnostic,
  Effect,
  ErrorSeverity,
  parseConfigPragmaForTests,
@@ -20,9 +19,7 @@ import BabelPluginReactCompiler, {
  PluginOptions,
  CompilerPipelineValue,
  parsePluginOptions,
-  printReactiveFunctionWithOutlined,
-  printFunctionWithOutlined,
-} from 'babel-plugin-react-compiler';
+} from 'babel-plugin-react-compiler/src';
 import clsx from 'clsx';
 import invariant from 'invariant';
 import {useSnackbar} from 'notistack';
@@ -37,7 +34,6 @@ import {
  type Store,
 } from '../../lib/stores';
 import {useStore, useStoreDispatch} from '../StoreContext';
-import ConfigEditor from './ConfigEditor';
 import Input from './Input';
 import {
  CompilerOutput,
@@ -45,9 +41,9 @@ import {
  default as Output,
  PrintedCompilerPipelineValue,
 } from './Output';
+import {printFunctionWithOutlined} from 'babel-plugin-react-compiler/src/HIR/PrintHIR';
+import {printReactiveFunctionWithOutlined} from 'babel-plugin-react-compiler/src/ReactiveScopes/PrintReactiveFunction';
 import {transformFromAstSync} from '@babel/core';
-import {LoggerEvent} from 'babel-plugin-react-compiler/dist/Entrypoint';
-import {useSearchParams} from 'next/navigation';

 function parseInput(
  input: string,
@@ -144,13 +140,9 @@ const COMMON_HOOKS: Array<[string, Hook]> = [
  ],
 ];

-function compile(
-  source: string,
-  mode: 'compiler' | 'linter',
-): [CompilerOutput, 'flow' | 'typescript'] {
+function compile(source: string): [CompilerOutput, 'flow' | 'typescript'] {
  const results = new Map<string, Array<PrintedCompilerPipelineValue>>();
  const error = new CompilerError();
-  const otherErrors: Array<CompilerErrorDetail | CompilerDiagnostic> = [];
  const upsert: (result: PrintedCompilerPipelineValue) => void = result => {
    const entry = results.get(result.name);
    if (Array.isArray(entry)) {
@@ -209,23 +201,6 @@ function compile(
    };
    const parsedOptions = parseConfigPragmaForTests(pragma, {
      compilationMode: 'infer',
-      environment:
-        mode === 'linter'
-          ? {
-              // enabled in compiler
-              validateRefAccessDuringRender: false,
-              // enabled in linter
-              validateNoSetStateInRender: true,
-              validateNoSetStateInEffects: true,
-              validateNoJSXInTryStatements: true,
-              validateNoImpureFunctionsInRender: true,
-              validateStaticComponents: true,
-              validateNoFreezingKnownMutableFunctions: true,
-              validateNoVoidUseMemo: true,
-            }
-          : {
-              /* use defaults for compiler mode */
-            },
    });
    const opts: PluginOptions = parsePluginOptions({
      ...parsedOptions,
@@ -235,11 +210,7 @@ function compile(
      },
      logger: {
        debugLogIRs: logIR,
-        logEvent: (_filename: string | null, event: LoggerEvent) => {
-          if (event.kind === 'CompileError') {
-            otherErrors.push(event.detail);
-          }
-        },
+        logEvent: () => {},
      },
    });
    transformOutput = invokeCompiler(source, language, opts);
@@ -249,7 +220,7 @@ function compile(
     * (i.e. object shape that is not CompilerError)
     */
    if (err instanceof CompilerError && err.details.length > 0) {
-      error.merge(err);
+      error.details.push(...err.details);
    } else {
      /**
       * Handle unexpected failures by logging (to get a stack trace)
@@ -266,17 +237,10 @@ function compile(
      );
    }
  }
-  // Only include logger errors if there weren't other errors
-  if (!error.hasErrors() && otherErrors.length !== 0) {
-    otherErrors.forEach(e => error.details.push(e));
-  }
  if (error.hasErrors()) {
-    return [{kind: 'err', results, error}, language];
+    return [{kind: 'err', results, error: error}, language];
  }
-  return [
-    {kind: 'ok', results, transformOutput, errors: error.details},
-    language,
-  ];
+  return [{kind: 'ok', results, transformOutput}, language];
 }

 export default function Editor(): JSX.Element {
@@ -285,21 +249,11 @@ export default function Editor(): JSX.Element {
  const dispatchStore = useStoreDispatch();
  const {enqueueSnackbar} = useSnackbar();
  const [compilerOutput, language] = useMemo(
-    () => compile(deferredStore.source, 'compiler'),
+    () => compile(deferredStore.source),
    [deferredStore.source],
  );
-  const [linterOutput] = useMemo(
-    () => compile(deferredStore.source, 'linter'),
-    [deferredStore.source],
-  );
-
-  // TODO: Remove this once the config editor is more stable
-  const searchParams = useSearchParams();
-  const search = searchParams.get('showConfig');
-  const shouldShowConfig = search === 'true';

  useMountEffect(() => {
-    // Initialize store
    let mountStore: Store;
    try {
      mountStore = initStoreFromUrlOrLocalStorage();
@@ -321,27 +275,19 @@ export default function Editor(): JSX.Element {
    });
  });

-  let mergedOutput: CompilerOutput;
-  let errors: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  if (compilerOutput.kind === 'ok') {
-    errors = linterOutput.kind === 'ok' ? [] : linterOutput.error.details;
-    mergedOutput = {
-      ...compilerOutput,
-      errors,
-    };
-  } else {
-    mergedOutput = compilerOutput;
-    errors = compilerOutput.error.details;
-  }
  return (
    <>
      <div className="relative flex basis top-14">
-        {shouldShowConfig && <ConfigEditor />}
        <div className={clsx('relative sm:basis-1/4')}>
-          <Input language={language} errors={errors} />
+          <Input
+            language={language}
+            errors={
+              compilerOutput.kind === 'err' ? compilerOutput.error.details : []
+            }
+          />
        </div>
        <div className={clsx('flex sm:flex flex-wrap')}>
-          <Output store={deferredStore} compilerOutput={mergedOutput} />
+          <Output store={deferredStore} compilerOutput={compilerOutput} />
        </div>
      </div>
    </>
--- a/compiler/apps/playground/components/Editor/Input.tsx
+++ b/compiler/apps/playground/components/Editor/Input.tsx
@@ -6,7 +6,7 @@
 */

 import MonacoEditor, {loader, type Monaco} from '@monaco-editor/react';
-import {CompilerErrorDetail} from 'babel-plugin-react-compiler';
+import {CompilerErrorDetail} from 'babel-plugin-react-compiler/src';
 import invariant from 'invariant';
 import type {editor} from 'monaco-editor';
 import * as monaco from 'monaco-editor';
@@ -36,18 +36,13 @@ export default function Input({errors, language}: Props): JSX.Element {
    const uri = monaco.Uri.parse(`file:///index.js`);
    const model = monaco.editor.getModel(uri);
    invariant(model, 'Model must exist for the selected input file.');
-    renderReactCompilerMarkers({
-      monaco,
-      model,
-      details: errors,
-      source: store.source,
-    });
+    renderReactCompilerMarkers({monaco, model, details: errors});
    /**
     * N.B. that `tabSize` is a model property, not an editor property.
     * So, the tab size has to be set per model.
     */
    model.updateOptions({tabSize: 2});
-  }, [monaco, errors, store.source]);
+  }, [monaco, errors]);

  useEffect(() => {
    /**
--- a/compiler/apps/playground/components/Editor/Output.tsx
+++ b/compiler/apps/playground/components/Editor/Output.tsx
@@ -11,11 +11,7 @@ import {
  InformationCircleIcon,
 } from '@heroicons/react/outline';
 import MonacoEditor, {DiffEditor} from '@monaco-editor/react';
-import {
-  CompilerErrorDetail,
-  CompilerDiagnostic,
-  type CompilerError,
-} from 'babel-plugin-react-compiler';
+import {type CompilerError} from 'babel-plugin-react-compiler/src';
 import parserBabel from 'prettier/plugins/babel';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettier from 'prettier/standalone';
@@ -48,7 +44,6 @@ export type CompilerOutput =
      kind: 'ok';
      transformOutput: CompilerTransformOutput;
      results: Map<string, Array<PrintedCompilerPipelineValue>>;
-      errors: Array<CompilerErrorDetail | CompilerDiagnostic>;
    }
  | {
      kind: 'err';
@@ -128,36 +123,10 @@ async function tabify(
      parser: transformOutput.language === 'flow' ? 'babel-flow' : 'babel-ts',
      plugins: [parserBabel, prettierPluginEstree],
    });
-
-    let output: string;
-    let language: string;
-    if (compilerOutput.errors.length === 0) {
-      output = code;
-      language = 'javascript';
-    } else {
-      language = 'markdown';
-      output = `
-# Summary
-
-React Compiler compiled this function successfully, but there are lint errors that indicate potential issues with the original code.
-
-## ${compilerOutput.errors.length} Lint Errors
-
-${compilerOutput.errors.map(e => e.printErrorMessage(source, {eslint: false})).join('\n\n')}
-
-## Output
-
-\`\`\`js
-${code}
-\`\`\`
-`.trim();
-    }
-
    reorderedTabs.set(
-      'Output',
+      'JS',
      <TextTabContent
-        output={output}
-        language={language}
+        output={code}
        diff={null}
        showInfoPanel={false}></TextTabContent>,
    );
@@ -173,18 +142,6 @@ ${code}
        </>,
      );
    }
-  } else if (compilerOutput.kind === 'err') {
-    const errors = compilerOutput.error.printErrorMessage(source, {
-      eslint: false,
-    });
-    reorderedTabs.set(
-      'Output',
-      <TextTabContent
-        output={errors}
-        language="markdown"
-        diff={null}
-        showInfoPanel={false}></TextTabContent>,
-    );
  }
  tabs.forEach((tab, name) => {
    reorderedTabs.set(name, tab);
@@ -205,32 +162,17 @@ function getSourceMapUrl(code: string, map: string): string | null {
 }

 function Output({store, compilerOutput}: Props): JSX.Element {
-  const [tabsOpen, setTabsOpen] = useState<Set<string>>(
-    () => new Set(['Output']),
-  );
+  const [tabsOpen, setTabsOpen] = useState<Set<string>>(() => new Set(['JS']));
  const [tabs, setTabs] = useState<Map<string, React.ReactNode>>(
    () => new Map(),
  );
-
-  /*
-   * Update the active tab back to the output or errors tab when the compilation state
-   * changes between success/failure.
-   */
-  const [previousOutputKind, setPreviousOutputKind] = useState(
-    compilerOutput.kind,
-  );
-  if (compilerOutput.kind !== previousOutputKind) {
-    setPreviousOutputKind(compilerOutput.kind);
-    setTabsOpen(new Set(['Output']));
-  }
-
  useEffect(() => {
    tabify(store.source, compilerOutput).then(tabs => {
      setTabs(tabs);
    });
  }, [store.source, compilerOutput]);

-  const changedPasses: Set<string> = new Set(['Output', 'HIR']); // Initial and final passes should always be bold
+  const changedPasses: Set<string> = new Set(['JS', 'HIR']); // Initial and final passes should always be bold
  let lastResult: string = '';
  for (const [passName, results] of compilerOutput.results) {
    for (const result of results) {
@@ -254,6 +196,20 @@ function Output({store, compilerOutput}: Props): JSX.Element {
        tabs={tabs}
        changedPasses={changedPasses}
      />
+      {compilerOutput.kind === 'err' ? (
+        <div
+          className="flex flex-wrap absolute bottom-0 bg-white grow border-y border-grey-200 transition-all ease-in"
+          style={{width: 'calc(100vw - 650px)'}}>
+          <div className="w-full p-4 basis-full border-b">
+            <h2>COMPILER ERRORS</h2>
+          </div>
+          <pre
+            className="p-4 basis-full text-red-600 overflow-y-scroll whitespace-pre-wrap"
+            style={{width: 'calc(100vw - 650px)', height: '150px'}}>
+            <code>{compilerOutput.error.toString()}</code>
+          </pre>
+        </div>
+      ) : null}
    </>
  );
 }
@@ -262,12 +218,10 @@ function TextTabContent({
  output,
  diff,
  showInfoPanel,
-  language,
 }: {
  output: string;
  diff: string | null;
  showInfoPanel: boolean;
-  language: string;
 }): JSX.Element {
  const [diffMode, setDiffMode] = useState(false);
  return (
@@ -318,7 +272,7 @@ function TextTabContent({
        />
      ) : (
        <MonacoEditor
-          language={language ?? 'javascript'}
+          defaultLanguage="javascript"
          value={output}
          options={{
            ...monacoOptions,
--- a/compiler/apps/playground/components/Editor/monacoOptions.ts
+++ b/compiler/apps/playground/components/Editor/monacoOptions.ts
@@ -28,5 +28,5 @@ export const monacoOptions: Partial<EditorProps['options']> = {

  automaticLayout: true,
  wordWrap: 'on',
-  wrappingIndent: 'same',
+  wrappingIndent: 'deepIndent',
 };
--- a/compiler/apps/playground/lib/reactCompilerMonacoDiagnostics.ts
+++ b/compiler/apps/playground/lib/reactCompilerMonacoDiagnostics.ts
@@ -7,10 +7,9 @@

 import {Monaco} from '@monaco-editor/react';
 import {
-  CompilerDiagnostic,
  CompilerErrorDetail,
  ErrorSeverity,
-} from 'babel-plugin-react-compiler';
+} from 'babel-plugin-react-compiler/src';
 import {MarkerSeverity, type editor} from 'monaco-editor';

 function mapReactCompilerSeverityToMonaco(
@@ -26,46 +25,38 @@ function mapReactCompilerSeverityToMonaco(
 }

 function mapReactCompilerDiagnosticToMonacoMarker(
-  detail: CompilerErrorDetail | CompilerDiagnostic,
+  detail: CompilerErrorDetail,
  monaco: Monaco,
-  source: string,
 ): editor.IMarkerData | null {
-  const loc = detail.primaryLocation();
-  if (loc == null || typeof loc === 'symbol') {
+  if (detail.loc == null || typeof detail.loc === 'symbol') {
    return null;
  }
  const severity = mapReactCompilerSeverityToMonaco(detail.severity, monaco);
-  let message = detail.printErrorMessage(source, {eslint: true});
+  let message = detail.printErrorMessage();
  return {
    severity,
    message,
-    startLineNumber: loc.start.line,
-    startColumn: loc.start.column + 1,
-    endLineNumber: loc.end.line,
-    endColumn: loc.end.column + 1,
+    startLineNumber: detail.loc.start.line,
+    startColumn: detail.loc.start.column + 1,
+    endLineNumber: detail.loc.end.line,
+    endColumn: detail.loc.end.column + 1,
  };
 }

 type ReactCompilerMarkerConfig = {
  monaco: Monaco;
  model: editor.ITextModel;
-  details: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  source: string;
+  details: Array<CompilerErrorDetail>;
 };
 let decorations: Array<string> = [];
 export function renderReactCompilerMarkers({
  monaco,
  model,
  details,
-  source,
 }: ReactCompilerMarkerConfig): void {
-  const markers: Array<editor.IMarkerData> = [];
+  let markers = [];
  for (const detail of details) {
-    const marker = mapReactCompilerDiagnosticToMonacoMarker(
-      detail,
-      monaco,
-      source,
-    );
+    const marker = mapReactCompilerDiagnosticToMonacoMarker(detail, monaco);
    if (marker == null) {
      continue;
    }
--- a/compiler/apps/playground/package.json
+++ b/compiler/apps/playground/package.json
@@ -4,7 +4,7 @@
  "private": true,
  "scripts": {
    "dev": "cd ../.. && concurrently --kill-others -n compiler,runtime,playground \"yarn workspace babel-plugin-react-compiler run watch\" \"yarn workspace react-compiler-runtime run watch\" \"wait-on packages/babel-plugin-react-compiler/dist/index.js && cd apps/playground && NODE_ENV=development next dev\"",
-    "build:compiler": "cd ../.. && concurrently -n compiler,runtime \"yarn workspace babel-plugin-react-compiler run build --dts\" \"yarn workspace react-compiler-runtime run build\"",
+    "build:compiler": "cd ../.. && concurrently -n compiler,runtime \"yarn workspace babel-plugin-react-compiler run build\" \"yarn workspace react-compiler-runtime run build\"",
    "build": "yarn build:compiler && next build",
    "postbuild": "node ./scripts/downloadFonts.js",
    "preinstall": "cd ../.. && yarn install --frozen-lockfile",
@@ -27,7 +27,7 @@
    "@babel/types": "7.26.3",
    "@heroicons/react": "^1.0.6",
    "@monaco-editor/react": "^4.4.6",
-    "@playwright/test": "^1.51.1",
+    "@playwright/test": "^1.42.1",
    "@use-gesture/react": "^10.2.22",
    "hermes-eslint": "^0.25.0",
    "hermes-parser": "^0.25.0",
--- a/compiler/apps/playground/scripts/link-compiler.sh
+++ b/compiler/apps/playground/scripts/link-compiler.sh
@@ -8,8 +8,8 @@ set -eo pipefail

 HERE=$(pwd)

-cd ../../packages/react-compiler-runtime && yarn --silent link && cd "$HERE"
-cd ../../packages/babel-plugin-react-compiler && yarn --silent link && cd "$HERE"
+cd ../../packages/react-compiler-runtime && yarn --silent link && cd $HERE
+cd ../../packages/babel-plugin-react-compiler && yarn --silent link && cd $HERE

 yarn --silent link babel-plugin-react-compiler
 yarn --silent link react-compiler-runtime
--- a/compiler/apps/playground/yarn.lock
+++ b/compiler/apps/playground/yarn.lock
@@ -781,12 +781,12 @@
  resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
  integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==

-"@playwright/test@^1.51.1":
-  version "1.51.1"
-  resolved "https://registry.yarnpkg.com/@playwright/test/-/test-1.51.1.tgz#75357d513221a7be0baad75f01e966baf9c41a2e"
-  integrity sha512-nM+kEaTSAoVlXmMPH10017vn3FSiFqr/bh4fKg9vmAdMfd9SDqRZNvPSiAHADc/itWak+qPvMPZQOPwCBW7k7Q==
+"@playwright/test@^1.42.1":
+  version "1.47.2"
+  resolved "https://registry.yarnpkg.com/@playwright/test/-/test-1.47.2.tgz#dbe7051336bfc5cc599954214f9111181dbc7475"
+  integrity sha512-jTXRsoSPONAs8Za9QEQdyjFn+0ZQFjCiIztAIF6bi1HqhBzG9Ma7g1WotyiGqFSBRZjIEqMdT8RUlbk1QVhzCQ==
  dependencies:
-    playwright "1.51.1"
+    playwright "1.47.2"

 "@rtsao/scc@^1.1.0":
  version "1.1.0"
@@ -1249,14 +1249,14 @@ camelcase-css@^2.0.1:
  integrity sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==

 caniuse-lite@^1.0.30001579:
-  version "1.0.30001715"
-  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001715.tgz"
-  integrity sha512-7ptkFGMm2OAOgvZpwgA4yjQ5SQbrNVGdRjzH0pBdy1Fasvcr+KAeECmbCAECzTuDuoX0FCY8KzUxjf9+9kfZEw==
+  version "1.0.30001669"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001669.tgz#fda8f1d29a8bfdc42de0c170d7f34a9cf19ed7a3"
+  integrity sha512-DlWzFDJqstqtIVx1zeSpIMLjunf5SmwOw0N2Ck/QSQdS8PLS4+9HrLaYei4w8BIAL7IB/UEDu889d8vhCTPA0w==

 caniuse-lite@^1.0.30001646, caniuse-lite@^1.0.30001663:
-  version "1.0.30001715"
-  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001715.tgz"
-  integrity sha512-7ptkFGMm2OAOgvZpwgA4yjQ5SQbrNVGdRjzH0pBdy1Fasvcr+KAeECmbCAECzTuDuoX0FCY8KzUxjf9+9kfZEw==
+  version "1.0.30001664"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001664.tgz#d588d75c9682d3301956b05a3749652a80677df4"
+  integrity sha512-AmE7k4dXiNKQipgn7a2xg558IRqPN3jMQY/rOsbxDhrd0tyChwbITBfiwtnqz8bi2M5mIWbxAYBvk7W7QBUS2g==

 chalk@^2.4.2:
  version "2.4.2"
@@ -3008,17 +3008,17 @@ pirates@^4.0.1:
  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.6.tgz#3018ae32ecfcff6c29ba2267cbf21166ac1f36b9"
  integrity sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==

-playwright-core@1.51.1:
-  version "1.51.1"
-  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.51.1.tgz#d57f0393e02416f32a47cf82b27533656a8acce1"
-  integrity sha512-/crRMj8+j/Nq5s8QcvegseuyeZPxpQCZb6HNk3Sos3BlZyAknRjoyJPFWkpNn8v0+P3WiwqFF8P+zQo4eqiNuw==
+playwright-core@1.47.2:
+  version "1.47.2"
+  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.47.2.tgz#7858da9377fa32a08be46ba47d7523dbd9460a4e"
+  integrity sha512-3JvMfF+9LJfe16l7AbSmU555PaTl2tPyQsVInqm3id16pdDfvZ8TTZ/pyzmkbDrZTQefyzU7AIHlZqQnxpqHVQ==

-playwright@1.51.1:
-  version "1.51.1"
-  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.51.1.tgz#ae1467ee318083968ad28d6990db59f47a55390f"
-  integrity sha512-kkx+MB2KQRkyxjYPc3a0wLZZoDczmppyGJIvQ43l+aZihkaVvmu/21kiyaHeHjiFxjxNNFnUncKmcGIyOojsaw==
+playwright@1.47.2:
+  version "1.47.2"
+  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.47.2.tgz#155688aa06491ee21fb3e7555b748b525f86eb20"
+  integrity sha512-nx1cLMmQWqmA3UsnjaaokyoUpdVaaDhJhMoxX2qj3McpjnsqFHs516QAKYhqHAgOP+oCFTEOCOAaD1RgD/RQfA==
  dependencies:
-    playwright-core "1.51.1"
+    playwright-core "1.47.2"
  optionalDependencies:
    fsevents "2.3.2"

--- a/compiler/package.json
+++ b/compiler/package.json
@@ -19,8 +19,7 @@
    "test": "yarn workspaces run test",
    "snap": "yarn workspace babel-plugin-react-compiler run snap",
    "snap:build": "yarn workspace snap run build",
-    "npm:publish": "node scripts/release/publish",
-    "eslint-docs": "yarn workspace babel-plugin-react-compiler build && node scripts/build-eslint-docs.js"
+    "npm:publish": "node scripts/release/publish"
  },
  "dependencies": {
    "fs-extra": "^4.0.2",
@@ -38,7 +37,7 @@
    "prettier": "^3.3.3",
    "prettier-plugin-hermes-parser": "^0.26.0",
    "prompt-promise": "^1.0.3",
-    "rimraf": "^6.0.1",
+    "rimraf": "^5.0.10",
    "to-fast-properties": "^2.0.0",
    "tsup": "^8.4.0",
    "typescript": "^5.4.3",
@@ -46,6 +45,7 @@
    "yargs": "^17.7.2"
  },
  "resolutions": {
+    "rimraf": "5.0.10",
    "@babel/types": "7.26.3"
  },
  "packageManager": "yarn@1.22.22"
--- a/compiler/packages/babel-plugin-react-compiler/package.json
+++ b/compiler/packages/babel-plugin-react-compiler/package.json
@@ -12,12 +12,12 @@
    "build": "rimraf dist && tsup",
    "test": "./scripts/link-react-compiler-runtime.sh && yarn snap:ci",
    "jest": "yarn build && ts-node node_modules/.bin/jest",
-    "snap": "yarn workspace snap run snap",
+    "snap": "node ../snap/dist/main.js",
    "snap:build": "yarn workspace snap run build",
    "snap:ci": "yarn snap:build && yarn snap",
    "ts:analyze-trace": "scripts/ts-analyze-trace.sh",
-    "lint": "yarn eslint src",
-    "watch": "yarn build --dts --watch"
+    "lint": "../../node_modules/eslint-v8/bin/eslint.js src",
+    "watch": "yarn build --watch"
  },
  "dependencies": {
    "@babel/types": "^7.26.0"
@@ -43,7 +43,7 @@
    "babel-jest": "^29.0.3",
    "babel-plugin-fbt": "^1.0.0",
    "babel-plugin-fbt-runtime": "^1.0.0",
-    "eslint": "^8.57.1",
+    "eslint-v8": "npm:eslint@^8.57.1",
    "invariant": "^2.2.4",
    "jest": "^29.0.3",
    "jest-environment-jsdom": "^29.0.3",
--- a/compiler/packages/babel-plugin-react-compiler/scripts/jest/e2e-forget.config.js
+++ b/compiler/packages/babel-plugin-react-compiler/scripts/jest/e2e-forget.config.js
@@ -7,4 +7,7 @@

 const makeE2EConfig = require('../jest/makeE2EConfig');

-module.exports = makeE2EConfig('e2e with forget', true);
+const config = makeE2EConfig('e2e with forget', true);
+config.setupFilesAfterEnv = ['<rootDir>/../scripts/jest/setupEnvE2E.js'];
+
+module.exports = config;
--- a/compiler/packages/babel-plugin-react-compiler/scripts/jest/makeTransform.ts
+++ b/compiler/packages/babel-plugin-react-compiler/scripts/jest/makeTransform.ts
@@ -5,16 +5,19 @@
 * LICENSE file in the root directory of this source tree.
 */

+import {jsx} from '@babel/plugin-syntax-jsx';
 import babelJest from 'babel-jest';
-import {
-  validateEnvironmentConfig,
-  EnvironmentConfig,
-} from 'babel-plugin-react-compiler';
+import {compile} from 'babel-plugin-react-compiler';
 import {execSync} from 'child_process';

 import type {NodePath, Visitor} from '@babel/traverse';
-import type {CallExpression} from '@babel/types';
-import BabelPluginReactCompiler from 'babel-plugin-react-compiler';
+import type {CallExpression, FunctionDeclaration} from '@babel/types';
+import * as t from '@babel/types';
+import {
+  EnvironmentConfig,
+  validateEnvironmentConfig,
+} from 'babel-plugin-react-compiler';
+import {basename} from 'path';

 /**
 * -- IMPORTANT --
@@ -25,19 +28,10 @@ import BabelPluginReactCompiler from 'babel-plugin-react-compiler';
 const e2eTransformerCacheKey = 1;
 const forgetOptions: EnvironmentConfig = validateEnvironmentConfig({
  enableAssumeHooksFollowRulesOfReact: true,
+  enableFunctionOutlining: false,
 });
 const debugMode = process.env['DEBUG_FORGET_COMPILER'] != null;

-const compilerCacheKey = execSync(
-  'yarn --silent --cwd ../.. hash packages/babel-plugin-react-compiler/dist',
-)
-  .toString()
-  .trim();
-
-if (debugMode) {
-  console.log('cachebreaker', compilerCacheKey);
-}
-
 module.exports = (useForget: boolean) => {
  function createTransformer() {
    return babelJest.createTransformer({
@@ -48,14 +42,15 @@ module.exports = (useForget: boolean) => {
          plugins: [
            useForget
              ? [
-                  BabelPluginReactCompiler,
+                  ReactForgetFunctionTransform,
                  {
-                    environment: forgetOptions,
                    /*
                     * Jest hashes the babel config as a cache breaker.
                     * (see https://github.com/jestjs/jest/blob/v29.6.2/packages/babel-jest/src/index.ts#L84)
                     */
-                    compilerCacheKey,
+                    compilerCacheKey: execSync(
+                      'yarn --silent --cwd ../.. hash packages/babel-plugin-react-compiler/dist',
+                    ).toString(),
                    transformOptionsCacheKey: forgetOptions,
                    e2eTransformerCacheKey,
                  },
@@ -110,3 +105,104 @@ module.exports = (useForget: boolean) => {
    createTransformer,
  };
 };
+
+// Mostly copied from react/scripts/babel/transform-forget.js
+function isReactComponentLike(fn: NodePath<FunctionDeclaration>): boolean {
+  let isReactComponent = false;
+  let hasNoUseForgetDirective = false;
+
+  /*
+   * React components start with an upper case letter,
+   * React hooks start with `use`
+   */
+  if (
+    fn.node.id == null ||
+    (fn.node.id.name[0].toUpperCase() !== fn.node.id.name[0] &&
+      !/^use[A-Z0-9]/.test(fn.node.id.name))
+  ) {
+    return false;
+  }
+
+  fn.traverse({
+    DirectiveLiteral(path) {
+      if (path.node.value === 'use no forget') {
+        hasNoUseForgetDirective = true;
+      }
+    },
+
+    JSX(path) {
+      // Is there is a JSX node created in the current function context?
+      if (path.scope.getFunctionParent()?.path.node === fn.node) {
+        isReactComponent = true;
+      }
+    },
+
+    CallExpression(path) {
+      // Is there hook usage?
+      if (
+        path.node.callee.type === 'Identifier' &&
+        !/^use[A-Z0-9]/.test(path.node.callee.name)
+      ) {
+        isReactComponent = true;
+      }
+    },
+  });
+
+  if (hasNoUseForgetDirective) {
+    return false;
+  }
+
+  return isReactComponent;
+}
+
+function ReactForgetFunctionTransform() {
+  const compiledFns = new Set();
+  const visitor = {
+    FunctionDeclaration(fn: NodePath<FunctionDeclaration>, state: any): void {
+      if (compiledFns.has(fn.node)) {
+        return;
+      }
+
+      if (!isReactComponentLike(fn)) {
+        return;
+      }
+      if (debugMode) {
+        const filename = basename(state.file.opts.filename);
+        if (fn.node.loc && fn.node.id) {
+          console.log(
+            ` Compiling ${filename}:${fn.node.loc.start.line}:${fn.node.loc.start.column}  ${fn.node.id.name}`,
+          );
+        } else {
+          console.log(` Compiling ${filename} ${fn.node.id?.name}`);
+        }
+      }
+
+      const compiled = compile(
+        fn,
+        forgetOptions,
+        'Other',
+        'all_features',
+        '_c',
+        null,
+        null,
+        null,
+      );
+      compiledFns.add(compiled);
+
+      const fun = t.functionDeclaration(
+        compiled.id,
+        compiled.params,
+        compiled.body,
+        compiled.generator,
+        compiled.async,
+      );
+      fn.replaceWith(fun);
+      fn.skip();
+    },
+  };
+  return {
+    name: 'react-forget-e2e',
+    inherits: jsx,
+    visitor,
+  };
+}
--- a/compiler/packages/babel-plugin-react-compiler/scripts/jest/setupEnvE2E.js
+++ b/compiler/packages/babel-plugin-react-compiler/scripts/jest/setupEnvE2E.js
@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+
+const ReactCompilerRuntime = require('react/compiler-runtime');
+
+/*
+ * Our e2e babel transform currently only compiles functions, not programs.
+ * As a result, our e2e transpiled code does not contain an import for the
+ * memo cache function. As a temporary hack, we add a `_c` global, which is
+ * the name that is used for the import by default.
+ */
+globalThis._c = ReactCompilerRuntime.c;
--- a/compiler/packages/babel-plugin-react-compiler/src/Babel/BabelPlugin.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Babel/BabelPlugin.ts
@@ -12,7 +12,6 @@ import {
  pipelineUsesReanimatedPlugin,
 } from '../Entrypoint/Reanimated';
 import validateNoUntransformedReferences from '../Entrypoint/ValidateNoUntransformedReferences';
-import {CompilerError} from '..';

 const ENABLE_REACT_COMPILER_TIMINGS =
  process.env['ENABLE_REACT_COMPILER_TIMINGS'] === '1';
@@ -35,58 +34,51 @@ export default function BabelPluginReactCompiler(
       */
      Program: {
        enter(prog, pass): void {
-          try {
-            const filename = pass.filename ?? 'unknown';
-            if (ENABLE_REACT_COMPILER_TIMINGS === true) {
-              performance.mark(`${filename}:start`, {
-                detail: 'BabelPlugin:Program:start',
-              });
-            }
-            let opts = parsePluginOptions(pass.opts);
-            const isDev =
-              (typeof __DEV__ !== 'undefined' && __DEV__ === true) ||
-              process.env['NODE_ENV'] === 'development';
-            if (
-              opts.enableReanimatedCheck === true &&
-              pipelineUsesReanimatedPlugin(pass.file.opts.plugins)
-            ) {
-              opts = injectReanimatedFlag(opts);
-            }
-            if (
-              opts.environment.enableResetCacheOnSourceFileChanges !== false &&
-              isDev
-            ) {
-              opts = {
-                ...opts,
-                environment: {
-                  ...opts.environment,
-                  enableResetCacheOnSourceFileChanges: true,
-                },
-              };
-            }
-            const result = compileProgram(prog, {
-              opts,
-              filename: pass.filename ?? null,
-              comments: pass.file.ast.comments ?? [],
-              code: pass.file.code,
+          const filename = pass.filename ?? 'unknown';
+          if (ENABLE_REACT_COMPILER_TIMINGS === true) {
+            performance.mark(`${filename}:start`, {
+              detail: 'BabelPlugin:Program:start',
+            });
+          }
+          let opts = parsePluginOptions(pass.opts);
+          const isDev =
+            (typeof __DEV__ !== 'undefined' && __DEV__ === true) ||
+            process.env['NODE_ENV'] === 'development';
+          if (
+            opts.enableReanimatedCheck === true &&
+            pipelineUsesReanimatedPlugin(pass.file.opts.plugins)
+          ) {
+            opts = injectReanimatedFlag(opts);
+          }
+          if (
+            opts.environment.enableResetCacheOnSourceFileChanges !== false &&
+            isDev
+          ) {
+            opts = {
+              ...opts,
+              environment: {
+                ...opts.environment,
+                enableResetCacheOnSourceFileChanges: true,
+              },
+            };
+          }
+          const result = compileProgram(prog, {
+            opts,
+            filename: pass.filename ?? null,
+            comments: pass.file.ast.comments ?? [],
+            code: pass.file.code,
+          });
+          validateNoUntransformedReferences(
+            prog,
+            pass.filename ?? null,
+            opts.logger,
+            opts.environment,
+            result?.retryErrors ?? [],
+          );
+          if (ENABLE_REACT_COMPILER_TIMINGS === true) {
+            performance.mark(`${filename}:end`, {
+              detail: 'BabelPlugin:Program:end',
            });
-            validateNoUntransformedReferences(
-              prog,
-              pass.filename ?? null,
-              opts.logger,
-              opts.environment,
-              result,
-            );
-            if (ENABLE_REACT_COMPILER_TIMINGS === true) {
-              performance.mark(`${filename}:end`, {
-                detail: 'BabelPlugin:Program:end',
-              });
-            }
-          } catch (e) {
-            if (e instanceof CompilerError) {
-              throw e.withPrintedMessage(pass.file.code, {eslint: false});
-            }
-            throw e;
          }
        },
        exit(_, pass): void {
--- a/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts
@@ -5,12 +5,8 @@
 * LICENSE file in the root directory of this source tree.
 */

-import * as t from '@babel/types';
-import {codeFrameColumns} from '@babel/code-frame';
-import {type SourceLocation} from './HIR';
-import {Err, Ok, Result} from './Utils/Result';
+import type {SourceLocation} from './HIR';
 import {assertExhaustive} from './Utils/utils';
-import invariant from 'invariant';

 export enum ErrorSeverity {
  /**
@@ -18,11 +14,6 @@ export enum ErrorSeverity {
   * misunderstanding on the user’s part.
   */
  InvalidJS = 'InvalidJS',
-  /**
-   * JS syntax that is not supported and which we do not plan to support. Developers should
-   * rewrite to use supported forms.
-   */
-  UnsupportedJS = 'UnsupportedJS',
  /**
   * Code that breaks the rules of React.
   */
@@ -47,29 +38,6 @@ export enum ErrorSeverity {
  Invariant = 'Invariant',
 }

-export type CompilerDiagnosticOptions = {
-  category: ErrorCategory;
-  severity: ErrorSeverity;
-  reason: string;
-  description: string;
-  details: Array<CompilerDiagnosticDetail>;
-  suggestions?: Array<CompilerSuggestion> | null | undefined;
-};
-
-export type CompilerDiagnosticDetail =
-  /**
-   * A/the source of the error
-   */
-  | {
-      kind: 'error';
-      loc: SourceLocation | null;
-      message: string;
-    }
-  | {
-      kind: 'hint';
-      message: string;
-    };
-
 export enum CompilerSuggestionOperation {
  InsertBefore,
  InsertAfter,
@@ -93,124 +61,13 @@ export type CompilerSuggestion =
    };

 export type CompilerErrorDetailOptions = {
-  category: ErrorCategory;
-  severity: ErrorSeverity;
  reason: string;
  description?: string | null | undefined;
+  severity: ErrorSeverity;
  loc: SourceLocation | null;
  suggestions?: Array<CompilerSuggestion> | null | undefined;
 };

-export type PrintErrorMessageOptions = {
-  /**
-   * ESLint uses 1-indexed columns and prints one error at a time
-   * So it doesn't require the "Found # error(s)" text
-   */
-  eslint: boolean;
-};
-
-export class CompilerDiagnostic {
-  options: CompilerDiagnosticOptions;
-
-  constructor(options: CompilerDiagnosticOptions) {
-    this.options = options;
-  }
-
-  static create(
-    options: Omit<CompilerDiagnosticOptions, 'details'>,
-  ): CompilerDiagnostic {
-    return new CompilerDiagnostic({...options, details: []});
-  }
-
-  get reason(): CompilerDiagnosticOptions['reason'] {
-    return this.options.reason;
-  }
-  get description(): CompilerDiagnosticOptions['description'] {
-    return this.options.description;
-  }
-  get severity(): CompilerDiagnosticOptions['severity'] {
-    return this.options.severity;
-  }
-  get suggestions(): CompilerDiagnosticOptions['suggestions'] {
-    return this.options.suggestions;
-  }
-  get category(): ErrorCategory {
-    return this.options.category;
-  }
-
-  withDetail(detail: CompilerDiagnosticDetail): CompilerDiagnostic {
-    this.options.details.push(detail);
-    return this;
-  }
-
-  primaryLocation(): SourceLocation | null {
-    const firstErrorDetail = this.options.details.filter(
-      d => d.kind === 'error',
-    )[0];
-    return firstErrorDetail != null && firstErrorDetail.kind === 'error'
-      ? firstErrorDetail.loc
-      : null;
-  }
-
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
-    const buffer = [
-      printErrorSummary(this.severity, this.reason),
-      '\n\n',
-      this.description,
-    ];
-    for (const detail of this.options.details) {
-      switch (detail.kind) {
-        case 'error': {
-          const loc = detail.loc;
-          if (loc == null || typeof loc === 'symbol') {
-            continue;
-          }
-          let codeFrame: string;
-          try {
-            codeFrame = printCodeFrame(source, loc, detail.message);
-          } catch (e) {
-            codeFrame = detail.message;
-          }
-          buffer.push('\n\n');
-          if (loc.filename != null) {
-            const line = loc.start.line;
-            const column = options.eslint
-              ? loc.start.column + 1
-              : loc.start.column;
-            buffer.push(`${loc.filename}:${line}:${column}\n`);
-          }
-          buffer.push(codeFrame);
-          break;
-        }
-        case 'hint': {
-          buffer.push('\n\n');
-          buffer.push(detail.message);
-          break;
-        }
-        default: {
-          assertExhaustive(
-            detail,
-            `Unexpected detail kind ${(detail as any).kind}`,
-          );
-        }
-      }
-    }
-    return buffer.join('');
-  }
-
-  toString(): string {
-    const buffer = [printErrorSummary(this.severity, this.reason)];
-    if (this.description != null) {
-      buffer.push(`. ${this.description}.`);
-    }
-    const loc = this.primaryLocation();
-    if (loc != null && typeof loc !== 'symbol') {
-      buffer.push(` (${loc.start.line}:${loc.start.column})`);
-    }
-    return buffer.join('');
-  }
-}
-
 /*
 * Each bailout or invariant in HIR lowering creates an {@link CompilerErrorDetail}, which is then
 * aggregated into a single {@link CompilerError} later.
@@ -237,66 +94,35 @@ export class CompilerErrorDetail {
  get suggestions(): CompilerErrorDetailOptions['suggestions'] {
    return this.options.suggestions;
  }
-  get category(): ErrorCategory {
-    return this.options.category;
-  }

-  primaryLocation(): SourceLocation | null {
-    return this.loc;
-  }
-
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
-    const buffer = [printErrorSummary(this.severity, this.reason)];
+  printErrorMessage(): string {
+    const buffer = [`${this.severity}: ${this.reason}`];
    if (this.description != null) {
-      buffer.push(`\n\n${this.description}.`);
+      buffer.push(`. ${this.description}`);
    }
-    const loc = this.loc;
-    if (loc != null && typeof loc !== 'symbol') {
-      let codeFrame: string;
-      try {
-        codeFrame = printCodeFrame(source, loc, this.reason);
-      } catch (e) {
-        codeFrame = '';
-      }
-      buffer.push(`\n\n`);
-      if (loc.filename != null) {
-        const line = loc.start.line;
-        const column = options.eslint ? loc.start.column + 1 : loc.start.column;
-        buffer.push(`${loc.filename}:${line}:${column}\n`);
-      }
-      buffer.push(codeFrame);
-      buffer.push('\n\n');
+    if (this.loc != null && typeof this.loc !== 'symbol') {
+      buffer.push(` (${this.loc.start.line}:${this.loc.end.line})`);
    }
    return buffer.join('');
  }

  toString(): string {
-    const buffer = [printErrorSummary(this.severity, this.reason)];
-    if (this.description != null) {
-      buffer.push(`. ${this.description}.`);
-    }
-    const loc = this.loc;
-    if (loc != null && typeof loc !== 'symbol') {
-      buffer.push(` (${loc.start.line}:${loc.start.column})`);
-    }
-    return buffer.join('');
+    return this.printErrorMessage();
  }
 }

 export class CompilerError extends Error {
-  details: Array<CompilerErrorDetail | CompilerDiagnostic> = [];
-  printedMessage: string | null = null;
+  details: Array<CompilerErrorDetail> = [];

  static invariant(
    condition: unknown,
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
  ): asserts condition {
    if (!condition) {
      const errors = new CompilerError();
      errors.pushErrorDetail(
        new CompilerErrorDetail({
          ...options,
-          category: ErrorCategory.Invariant,
          severity: ErrorSeverity.Invariant,
        }),
      );
@@ -304,35 +130,24 @@ export class CompilerError extends Error {
    }
  }

-  static throwDiagnostic(options: CompilerDiagnosticOptions): never {
-    const errors = new CompilerError();
-    errors.pushDiagnostic(new CompilerDiagnostic(options));
-    throw errors;
-  }
-
  static throwTodo(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
  ): never {
    const errors = new CompilerError();
    errors.pushErrorDetail(
-      new CompilerErrorDetail({
-        ...options,
-        severity: ErrorSeverity.Todo,
-        category: ErrorCategory.Todo,
-      }),
+      new CompilerErrorDetail({...options, severity: ErrorSeverity.Todo}),
    );
    throw errors;
  }

  static throwInvalidJS(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
  ): never {
    const errors = new CompilerError();
    errors.pushErrorDetail(
      new CompilerErrorDetail({
        ...options,
        severity: ErrorSeverity.InvalidJS,
-        category: ErrorCategory.Syntax,
      }),
    );
    throw errors;
@@ -352,14 +167,13 @@ export class CompilerError extends Error {
  }

  static throwInvalidConfig(
-    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
  ): never {
    const errors = new CompilerError();
    errors.pushErrorDetail(
      new CompilerErrorDetail({
        ...options,
        severity: ErrorSeverity.InvalidConfig,
-        category: ErrorCategory.Config,
      }),
    );
    throw errors;
@@ -378,52 +192,20 @@ export class CompilerError extends Error {
  }

  override get message(): string {
-    return this.printedMessage ?? this.toString();
+    return this.toString();
  }

  override set message(_message: string) {}

  override toString(): string {
-    if (this.printedMessage) {
-      return this.printedMessage;
-    }
    if (Array.isArray(this.details)) {
      return this.details.map(detail => detail.toString()).join('\n\n');
    }
    return this.name;
  }

-  withPrintedMessage(
-    source: string,
-    options: PrintErrorMessageOptions,
-  ): CompilerError {
-    this.printedMessage = this.printErrorMessage(source, options);
-    return this;
-  }
-
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
-    if (options.eslint && this.details.length === 1) {
-      return this.details[0].printErrorMessage(source, options);
-    }
-    return (
-      `Found ${this.details.length} error${this.details.length === 1 ? '' : 's'}:\n\n` +
-      this.details
-        .map(detail => detail.printErrorMessage(source, options).trim())
-        .join('\n\n')
-    );
-  }
-
-  merge(other: CompilerError): void {
-    this.details.push(...other.details);
-  }
-
-  pushDiagnostic(diagnostic: CompilerDiagnostic): void {
-    this.details.push(diagnostic);
-  }
-
  push(options: CompilerErrorDetailOptions): CompilerErrorDetail {
    const detail = new CompilerErrorDetail({
-      category: options.category,
      reason: options.reason,
      description: options.description ?? null,
      severity: options.severity,
@@ -442,10 +224,6 @@ export class CompilerError extends Error {
    return this.details.length > 0;
  }

-  asResult(): Result<void, CompilerError> {
-    return this.hasErrors() ? Err(this) : Ok(undefined);
-  }
-
  /*
   * An error is critical if it means the compiler has entered into a broken state and cannot
   * continue safely. Other expected errors such as Todos mean that we can skip over that component
@@ -458,424 +236,13 @@ export class CompilerError extends Error {
        case ErrorSeverity.InvalidJS:
        case ErrorSeverity.InvalidReact:
        case ErrorSeverity.InvalidConfig:
-        case ErrorSeverity.UnsupportedJS: {
          return true;
-        }
        case ErrorSeverity.CannotPreserveMemoization:
-        case ErrorSeverity.Todo: {
+        case ErrorSeverity.Todo:
          return false;
-        }
-        default: {
+        default:
          assertExhaustive(detail.severity, 'Unhandled error severity');
-        }
      }
    });
  }
 }
-
-function printCodeFrame(
-  source: string,
-  loc: t.SourceLocation,
-  message: string,
-): string {
-  return codeFrameColumns(
-    source,
-    {
-      start: {
-        line: loc.start.line,
-        column: loc.start.column + 1,
-      },
-      end: {
-        line: loc.end.line,
-        column: loc.end.column + 1,
-      },
-    },
-    {
-      message,
-    },
-  );
-}
-
-function printErrorSummary(severity: ErrorSeverity, message: string): string {
-  let severityCategory: string;
-  switch (severity) {
-    case ErrorSeverity.InvalidConfig:
-    case ErrorSeverity.InvalidJS:
-    case ErrorSeverity.InvalidReact:
-    case ErrorSeverity.UnsupportedJS: {
-      severityCategory = 'Error';
-      break;
-    }
-    case ErrorSeverity.CannotPreserveMemoization: {
-      severityCategory = 'Memoization';
-      break;
-    }
-    case ErrorSeverity.Invariant: {
-      severityCategory = 'Invariant';
-      break;
-    }
-    case ErrorSeverity.Todo: {
-      severityCategory = 'Todo';
-      break;
-    }
-    default: {
-      assertExhaustive(severity, `Unexpected severity '${severity}'`);
-    }
-  }
-  return `${severityCategory}: ${message}`;
-}
-
-/**
- * See getRuleForCategory() for how these map to ESLint rules
- */
-export enum ErrorCategory {
-  // Checking for valid hooks usage (non conditional, non-first class, non reactive, etc)
-  Hooks = 'Hooks',
-
-  // Checking for no capitalized calls (not definitively an error, hence separating)
-  CapitalizedCalls = 'CapitalizedCalls',
-
-  // Checking for static components
-  StaticComponents = 'StaticComponents',
-
-  // Checking for valid usage of manual memoization
-  UseMemo = 'UseMemo',
-
-  // Checking for higher order functions acting as factories for components/hooks
-  Factories = 'Factories',
-
-  // Checks that manual memoization is preserved
-  PreserveManualMemo = 'PreserveManualMemo',
-
-  // Checking for no mutations of props, hook arguments, hook return values
-  Immutability = 'Immutability',
-
-  // Checking for assignments to globals
-  Globals = 'Globals',
-
-  // Checking for valid usage of refs, ie no access during render
-  Refs = 'Refs',
-
-  // Checks for memoized effect deps
-  EffectDependencies = 'EffectDependencies',
-
-  // Checks for no setState in effect bodies
-  EffectSetState = 'EffectSetState',
-
-  EffectDerivationsOfState = 'EffectDerivationsOfState',
-
-  // Validates against try/catch in place of error boundaries
-  ErrorBoundaries = 'ErrorBoundaries',
-
-  // Checking for pure functions
-  Purity = 'Purity',
-
-  // Validates against setState in render
-  RenderSetState = 'RenderSetState',
-
-  // Internal invariants
-  Invariant = 'Invariant',
-
-  // Todos
-  Todo = 'Todo',
-
-  // Syntax errors
-  Syntax = 'Syntax',
-
-  // Checks for use of unsupported syntax
-  UnsupportedSyntax = 'UnsupportedSyntax',
-
-  // Config errors
-  Config = 'Config',
-
-  // Gating error
-  Gating = 'Gating',
-
-  // Suppressions
-  Suppression = 'Suppression',
-
-  // Issues with auto deps
-  AutomaticEffectDependencies = 'AutomaticEffectDependencies',
-
-  // Issues with `fire`
-  Fire = 'Fire',
-
-  // fbt-specific issues
-  FBT = 'FBT',
-}
-
-export type LintRule = {
-  // Stores the category the rule corresponds to, used to filter errors when reporting
-  category: ErrorCategory;
-
-  /**
-   * The "name" of the rule as it will be used by developers to enable/disable, eg
-   * "eslint-disable-nest line <name>"
-   */
-  name: string;
-
-  /**
-   * A description of the rule that appears somewhere in ESLint. This does not affect
-   * how error messages are formatted
-   */
-  description: string;
-
-  /**
-   * If true, this rule will automatically appear in the default, "recommended" ESLint
-   * rule set. Otherwise it will be part of an `allRules` export that developers can
-   * use to opt-in to showing output of all possible rules.
-   *
-   * NOTE: not all validations are enabled by default! Setting this flag only affects
-   * whether a given rule is part of the recommended set. The corresponding validation
-   * also should be enabled by default if you want the error to actually show up!
-   */
-  recommended: boolean;
-};
-
-const RULE_NAME_PATTERN = /^[a-z]+(-[a-z]+)*$/;
-
-export function getRuleForCategory(category: ErrorCategory): LintRule {
-  const rule = getRuleForCategoryImpl(category);
-  invariant(
-    RULE_NAME_PATTERN.test(rule.name),
-    `Invalid rule name, got '${rule.name}' but rules must match ${RULE_NAME_PATTERN.toString()}`,
-  );
-  return rule;
-}
-
-function getRuleForCategoryImpl(category: ErrorCategory): LintRule {
-  switch (category) {
-    case ErrorCategory.AutomaticEffectDependencies: {
-      return {
-        category,
-        name: 'automatic-effect-dependencies',
-        description:
-          'Verifies that automatic effect dependencies are compiled if opted-in',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.CapitalizedCalls: {
-      return {
-        category,
-        name: 'capitalized-calls',
-        description:
-          'Validates against calling capitalized functions/methods instead of using JSX',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Config: {
-      return {
-        category,
-        name: 'config',
-        description: 'Validates the compiler configuration options',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.EffectDependencies: {
-      return {
-        category,
-        name: 'memoized-effect-dependencies',
-        description: 'Validates that effect dependencies are memoized',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.EffectDerivationsOfState: {
-      return {
-        category,
-        name: 'no-deriving-state-in-effects',
-        description:
-          'Validates against deriving values from state in an effect',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.EffectSetState: {
-      return {
-        category,
-        name: 'set-state-in-effect',
-        description:
-          'Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.ErrorBoundaries: {
-      return {
-        category,
-        name: 'error-boundaries',
-        description:
-          'Validates usage of error boundaries instead of try/catch for errors in child components',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Factories: {
-      return {
-        category,
-        name: 'component-hook-factories',
-        description:
-          'Validates against higher order functions defining nested components or hooks. ' +
-          'Components and hooks should be defined at the module level',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.FBT: {
-      return {
-        category,
-        name: 'fbt',
-        description: 'Validates usage of fbt',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Fire: {
-      return {
-        category,
-        name: 'fire',
-        description: 'Validates usage of `fire`',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Gating: {
-      return {
-        category,
-        name: 'gating',
-        description:
-          'Validates configuration of [gating mode](https://react.dev/reference/react-compiler/gating)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Globals: {
-      return {
-        category,
-        name: 'globals',
-        description:
-          'Validates against assignment/mutation of globals during render, part of ensuring that ' +
-          '[side effects must render outside of render](https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Hooks: {
-      return {
-        category,
-        name: 'hooks',
-        description: 'Validates the rules of hooks',
-        /**
-         * TODO: the "Hooks" rule largely reimplements the "rules-of-hooks" non-compiler rule.
-         * We need to dedeupe these (moving the remaining bits into the compiler) and then enable
-         * this rule.
-         */
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Immutability: {
-      return {
-        category,
-        name: 'immutability',
-        description:
-          'Validates against mutating props, state, and other values that [are immutable](https://react.dev/reference/rules/components-and-hooks-must-be-pure#props-and-state-are-immutable)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Invariant: {
-      return {
-        category,
-        name: 'invariant',
-        description: 'Internal invariants',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.PreserveManualMemo: {
-      return {
-        category,
-        name: 'preserve-manual-memoization',
-        description:
-          'Validates that existing manual memoized is preserved by the compiler. ' +
-          'React Compiler will only compile components and hooks if its inference ' +
-          '[matches or exceeds the existing manual memoization](https://react.dev/learn/react-compiler/introduction#what-should-i-do-about-usememo-usecallback-and-reactmemo)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Purity: {
-      return {
-        category,
-        name: 'purity',
-        description:
-          'Validates that [components/hooks are pure](https://react.dev/reference/rules/components-and-hooks-must-be-pure) by checking that they do not call known-impure functions',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Refs: {
-      return {
-        category,
-        name: 'refs',
-        description:
-          'Validates correct usage of refs, not reading/writing during render. See the "pitfalls" section in [`useRef()` usage](https://react.dev/reference/react/useRef#usage)',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.RenderSetState: {
-      return {
-        category,
-        name: 'set-state-in-render',
-        description:
-          'Validates against setting state during render, which can trigger additional renders and potential infinite render loops',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.StaticComponents: {
-      return {
-        category,
-        name: 'static-components',
-        description:
-          'Validates that components are static, not recreated every render. Components that are recreated dynamically can reset state and trigger excessive re-rendering',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.Suppression: {
-      return {
-        category,
-        name: 'rule-suppression',
-        description: 'Validates against suppression of other rules',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Syntax: {
-      return {
-        category,
-        name: 'syntax',
-        description: 'Validates against invalid syntax',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.Todo: {
-      return {
-        category,
-        name: 'todo',
-        description: 'Unimplemented features',
-        recommended: false,
-      };
-    }
-    case ErrorCategory.UnsupportedSyntax: {
-      return {
-        category,
-        name: 'unsupported-syntax',
-        description:
-          'Validates against syntax that we do not plan to support in React Compiler',
-        recommended: true,
-      };
-    }
-    case ErrorCategory.UseMemo: {
-      return {
-        category,
-        name: 'use-memo',
-        description:
-          'Validates usage of the useMemo() hook against common mistakes. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
-        recommended: true,
-      };
-    }
-    default: {
-      assertExhaustive(category, `Unsupported category ${category}`);
-    }
-  }
-}
-
-export const LintRules: Array<LintRule> = Object.keys(ErrorCategory).map(
-  category => getRuleForCategory(category as any),
-);
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Gating.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Gating.ts
@@ -7,9 +7,8 @@

 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
+import {PluginOptions} from './Options';
 import {CompilerError} from '../CompilerError';
-import {ProgramContext} from './Imports';
-import {ExternalFunction} from '..';

 /**
 * Gating rewrite for function declarations which are referenced before their
@@ -35,8 +34,7 @@ import {ExternalFunction} from '..';
 function insertAdditionalFunctionDeclaration(
  fnPath: NodePath<t.FunctionDeclaration>,
  compiled: t.FunctionDeclaration,
-  programContext: ProgramContext,
-  gatingFunctionIdentifierName: string,
+  gating: NonNullable<PluginOptions['gating']>,
 ): void {
  const originalFnName = fnPath.node.id;
  const originalFnParams = fnPath.node.params;
@@ -59,14 +57,14 @@ function insertAdditionalFunctionDeclaration(
    loc: fnPath.node.loc ?? null,
  });

-  const gatingCondition = t.identifier(
-    programContext.newUid(`${gatingFunctionIdentifierName}_result`),
+  const gatingCondition = fnPath.scope.generateUidIdentifier(
+    `${gating.importSpecifierName}_result`,
  );
-  const unoptimizedFnName = t.identifier(
-    programContext.newUid(`${originalFnName.name}_unoptimized`),
+  const unoptimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_unoptimized`,
  );
-  const optimizedFnName = t.identifier(
-    programContext.newUid(`${originalFnName.name}_optimized`),
+  const optimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_optimized`,
  );
  /**
   * Step 1: rename existing functions
@@ -117,7 +115,7 @@ function insertAdditionalFunctionDeclaration(
    t.variableDeclaration('const', [
      t.variableDeclarator(
        gatingCondition,
-        t.callExpression(t.identifier(gatingFunctionIdentifierName), []),
+        t.callExpression(t.identifier(gating.importSpecifierName), []),
      ),
    ]),
  );
@@ -131,26 +129,19 @@ export function insertGatedFunctionDeclaration(
    | t.FunctionDeclaration
    | t.ArrowFunctionExpression
    | t.FunctionExpression,
-  programContext: ProgramContext,
-  gating: ExternalFunction,
+  gating: NonNullable<PluginOptions['gating']>,
  referencedBeforeDeclaration: boolean,
 ): void {
-  const gatingImportedName = programContext.addImportSpecifier(gating).name;
  if (referencedBeforeDeclaration && fnPath.isFunctionDeclaration()) {
    CompilerError.invariant(compiled.type === 'FunctionDeclaration', {
      reason: 'Expected compiled node type to match input type',
      description: `Got ${compiled.type} but expected FunctionDeclaration`,
      loc: fnPath.node.loc ?? null,
    });
-    insertAdditionalFunctionDeclaration(
-      fnPath,
-      compiled,
-      programContext,
-      gatingImportedName,
-    );
+    insertAdditionalFunctionDeclaration(fnPath, compiled, gating);
  } else {
    const gatingExpression = t.conditionalExpression(
-      t.callExpression(t.identifier(gatingImportedName), []),
+      t.callExpression(t.identifier(gating.importSpecifierName), []),
      buildFunctionExpression(compiled),
      buildFunctionExpression(fnPath.node),
    );
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Imports.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Imports.ts
@@ -7,20 +7,9 @@

 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
-import {Scope as BabelScope} from '@babel/traverse';
-
-import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
-import {
-  EnvironmentConfig,
-  GeneratedSource,
-  NonLocalImportSpecifier,
-} from '../HIR';
-import {getOrInsertWith} from '../Utils/utils';
-import {ExternalFunction, isHookName} from '../HIR/Environment';
-import {Err, Ok, Result} from '../Utils/Result';
-import {LoggerEvent, PluginOptions} from './Options';
-import {BabelFn, getReactCompilerRuntimeModule} from './Program';
-import {SuppressionRange} from './Suppression';
+import {CompilerError, ErrorSeverity} from '../CompilerError';
+import {EnvironmentConfig, ExternalFunction, GeneratedSource} from '../HIR';
+import {getOrInsertDefault} from '../Utils/utils';

 export function validateRestrictedImports(
  path: NodePath<t.Program>,
@@ -38,7 +27,6 @@ export function validateRestrictedImports(
    ImportDeclaration(importDeclPath) {
      if (restrictedImports.has(importDeclPath.node.source.value)) {
        error.push({
-          category: ErrorCategory.Todo,
          severity: ErrorSeverity.Todo,
          reason: 'Bailing out due to blocklisted import',
          description: `Import from module ${importDeclPath.node.source.value}`,
@@ -54,249 +42,50 @@ export function validateRestrictedImports(
  }
 }

-type ProgramContextOptions = {
-  program: NodePath<t.Program>;
-  suppressions: Array<SuppressionRange>;
-  opts: PluginOptions;
-  filename: string | null;
-  code: string | null;
-  hasModuleScopeOptOut: boolean;
-};
-export class ProgramContext {
-  /**
-   * Program and environment context
-   */
-  scope: BabelScope;
-  opts: PluginOptions;
-  filename: string | null;
-  code: string | null;
-  reactRuntimeModule: string;
-  suppressions: Array<SuppressionRange>;
-  hasModuleScopeOptOut: boolean;
-
-  /*
-   * This is a hack to work around what seems to be a Babel bug. Babel doesn't
-   * consistently respect the `skip()` function to avoid revisiting a node within
-   * a pass, so we use this set to track nodes that we have compiled.
-   */
-  alreadyCompiled: WeakSet<object> | Set<object> = new (WeakSet ?? Set)();
-  // known generated or referenced identifiers in the program
-  knownReferencedNames: Set<string> = new Set();
-  // generated imports
-  imports: Map<string, Map<string, NonLocalImportSpecifier>> = new Map();
-
-  /**
-   * Metadata from compilation
-   */
-  retryErrors: Array<{fn: BabelFn; error: CompilerError}> = [];
-  inferredEffectLocations: Set<t.SourceLocation> = new Set();
-
-  constructor({
-    program,
-    suppressions,
-    opts,
-    filename,
-    code,
-    hasModuleScopeOptOut,
-  }: ProgramContextOptions) {
-    this.scope = program.scope;
-    this.opts = opts;
-    this.filename = filename;
-    this.code = code;
-    this.reactRuntimeModule = getReactCompilerRuntimeModule(opts.target);
-    this.suppressions = suppressions;
-    this.hasModuleScopeOptOut = hasModuleScopeOptOut;
-  }
-
-  isHookName(name: string): boolean {
-    if (this.opts.environment.hookPattern == null) {
-      return isHookName(name);
-    } else {
-      const match = new RegExp(this.opts.environment.hookPattern).exec(name);
-      return (
-        match != null && typeof match[1] === 'string' && isHookName(match[1])
-      );
-    }
-  }
-
-  hasReference(name: string): boolean {
-    return (
-      this.knownReferencedNames.has(name) ||
-      this.scope.hasBinding(name) ||
-      this.scope.hasGlobal(name) ||
-      this.scope.hasReference(name)
-    );
-  }
-
-  newUid(name: string): string {
-    /**
-     * Don't call babel's generateUid for known hook imports, as
-     * InferTypes might eventually type `HookKind` based on callee naming
-     * convention and `_useFoo` is not named as a hook.
-     *
-     * Local uid generation is susceptible to check-before-use bugs since we're
-     * checking for naming conflicts / references long before we actually insert
-     * the import. (see similar logic in HIRBuilder:resolveBinding)
-     */
-    let uid;
-    if (this.isHookName(name)) {
-      uid = name;
-      let i = 0;
-      while (this.hasReference(uid)) {
-        this.knownReferencedNames.add(uid);
-        uid = `${name}_${i++}`;
-      }
-    } else if (!this.hasReference(name)) {
-      uid = name;
-    } else {
-      uid = this.scope.generateUid(name);
-    }
-    this.knownReferencedNames.add(uid);
-    return uid;
-  }
-
-  addMemoCacheImport(): NonLocalImportSpecifier {
-    return this.addImportSpecifier(
-      {
-        source: this.reactRuntimeModule,
-        importSpecifierName: 'c',
-      },
-      '_c',
-    );
-  }
-
-  /**
-   *
-   * @param externalFunction
-   * @param nameHint if defined, will be used as the name of the import specifier
-   * @returns
-   */
-  addImportSpecifier(
-    {source: module, importSpecifierName: specifier}: ExternalFunction,
-    nameHint?: string,
-  ): NonLocalImportSpecifier {
-    const maybeBinding = this.imports.get(module)?.get(specifier);
-    if (maybeBinding != null) {
-      return {...maybeBinding};
-    }
-
-    const binding: NonLocalImportSpecifier = {
-      kind: 'ImportSpecifier',
-      name: this.newUid(nameHint ?? specifier),
-      module,
-      imported: specifier,
-    };
-    getOrInsertWith(this.imports, module, () => new Map()).set(specifier, {
-      ...binding,
-    });
-    return binding;
-  }
-
-  addNewReference(name: string): void {
-    this.knownReferencedNames.add(name);
-  }
-
-  assertGlobalBinding(
-    name: string,
-    localScope?: BabelScope,
-  ): Result<void, CompilerError> {
-    const scope = localScope ?? this.scope;
-    if (!scope.hasReference(name) && !scope.hasBinding(name)) {
-      return Ok(undefined);
-    }
-    const error = new CompilerError();
-    error.push({
-      category: ErrorCategory.Todo,
-      severity: ErrorSeverity.Todo,
-      reason: 'Encountered conflicting global in generated program',
-      description: `Conflict from local binding ${name}`,
-      loc: scope.getBinding(name)?.path.node.loc ?? null,
-      suggestions: null,
-    });
-    return Err(error);
-  }
-
-  logEvent(event: LoggerEvent): void {
-    if (this.opts.logger != null) {
-      this.opts.logger.logEvent(this.filename, event);
-    }
-  }
-}
-
-function getExistingImports(
-  program: NodePath<t.Program>,
-): Map<string, NodePath<t.ImportDeclaration>> {
-  const existingImports = new Map<string, NodePath<t.ImportDeclaration>>();
-  program.traverse({
-    ImportDeclaration(path) {
-      if (isNonNamespacedImport(path)) {
-        existingImports.set(path.node.source.value, path);
-      }
-    },
-  });
-  return existingImports;
-}
-
 export function addImportsToProgram(
  path: NodePath<t.Program>,
-  programContext: ProgramContext,
+  importList: Array<ExternalFunction>,
 ): void {
-  const existingImports = getExistingImports(path);
+  const identifiers: Set<string> = new Set();
+  const sortedImports: Map<string, Array<string>> = new Map();
+  for (const {importSpecifierName, source} of importList) {
+    /*
+     * Codegen currently does not rename import specifiers, so we do additional
+     * validation here
+     */
+    CompilerError.invariant(identifiers.has(importSpecifierName) === false, {
+      reason: `Encountered conflicting import specifier for ${importSpecifierName} in Forget config.`,
+      description: null,
+      loc: GeneratedSource,
+      suggestions: null,
+    });
+    CompilerError.invariant(
+      path.scope.hasBinding(importSpecifierName) === false,
+      {
+        reason: `Encountered conflicting import specifiers for ${importSpecifierName} in generated program.`,
+        description: null,
+        loc: GeneratedSource,
+        suggestions: null,
+      },
+    );
+    identifiers.add(importSpecifierName);
+
+    const importSpecifierNameList = getOrInsertDefault(
+      sortedImports,
+      source,
+      [],
+    );
+    importSpecifierNameList.push(importSpecifierName);
+  }
+
  const stmts: Array<t.ImportDeclaration> = [];
-  const sortedModules = [...programContext.imports.entries()].sort(([a], [b]) =>
-    a.localeCompare(b),
-  );
-  for (const [moduleName, importsMap] of sortedModules) {
-    for (const [specifierName, loweredImport] of importsMap) {
-      /**
-       * Assert that the import identifier hasn't already be declared in the program.
-       * Note: we use getBinding here since `Scope.hasBinding` pessimistically returns true
-       * for all allocated uids (from `Scope.getUid`)
-       */
-      CompilerError.invariant(
-        path.scope.getBinding(loweredImport.name) == null,
-        {
-          reason:
-            'Encountered conflicting import specifiers in generated program',
-          description: `Conflict from import ${loweredImport.module}:(${loweredImport.imported} as ${loweredImport.name}).`,
-          loc: GeneratedSource,
-          suggestions: null,
-        },
-      );
-      CompilerError.invariant(
-        loweredImport.module === moduleName &&
-          loweredImport.imported === specifierName,
-        {
-          reason:
-            'Found inconsistent import specifier. This is an internal bug.',
-          description: `Expected import ${moduleName}:${specifierName} but found ${loweredImport.module}:${loweredImport.imported}`,
-          loc: GeneratedSource,
-        },
-      );
-    }
-    const sortedImport: Array<NonLocalImportSpecifier> = [
-      ...importsMap.values(),
-    ].sort(({imported: a}, {imported: b}) => a.localeCompare(b));
-    const importSpecifiers = sortedImport.map(specifier => {
-      return t.importSpecifier(
-        t.identifier(specifier.name),
-        t.identifier(specifier.imported),
-      );
+  for (const [source, importSpecifierNameList] of sortedImports) {
+    const importSpecifiers = importSpecifierNameList.map(name => {
+      const id = t.identifier(name);
+      return t.importSpecifier(id, id);
    });

-    /**
-     * If an existing import of this module exists (ie `import { ... } from
-     * '<moduleName>'`), inject new imported specifiers into the list of
-     * destructured variables.
-     */
-    const maybeExistingImports = existingImports.get(moduleName);
-    if (maybeExistingImports != null) {
-      maybeExistingImports.pushContainer('specifiers', importSpecifiers);
-    } else {
-      stmts.push(
-        t.importDeclaration(importSpecifiers, t.stringLiteral(moduleName)),
-      );
-    }
+    stmts.push(t.importDeclaration(importSpecifiers, t.stringLiteral(source)));
  }
  path.unshiftContainer('body', stmts);
 }
@@ -304,12 +93,13 @@ export function addImportsToProgram(
 /*
 * Matches `import { ... } from <moduleName>;`
 * but not `import * as React from <moduleName>;`
- *         `import type { Foo } from <moduleName>;`
 */
 function isNonNamespacedImport(
  importDeclPath: NodePath<t.ImportDeclaration>,
+  moduleName: string,
 ): boolean {
  return (
+    importDeclPath.get('source').node.value === moduleName &&
    importDeclPath
      .get('specifiers')
      .every(specifier => specifier.isImportSpecifier()) &&
@@ -317,3 +107,94 @@ function isNonNamespacedImport(
    importDeclPath.node.importKind !== 'typeof'
  );
 }
+
+function hasExistingNonNamespacedImportOfModule(
+  program: NodePath<t.Program>,
+  moduleName: string,
+): boolean {
+  let hasExistingImport = false;
+  program.traverse({
+    ImportDeclaration(importDeclPath) {
+      if (isNonNamespacedImport(importDeclPath, moduleName)) {
+        hasExistingImport = true;
+      }
+    },
+  });
+
+  return hasExistingImport;
+}
+
+/*
+ * If an existing import of React exists (ie `import { ... } from '<moduleName>'`), inject useMemoCache
+ * into the list of destructured variables.
+ */
+function addMemoCacheFunctionSpecifierToExistingImport(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  identifierName: string,
+): boolean {
+  let didInsertUseMemoCache = false;
+  program.traverse({
+    ImportDeclaration(importDeclPath) {
+      if (
+        !didInsertUseMemoCache &&
+        isNonNamespacedImport(importDeclPath, moduleName)
+      ) {
+        importDeclPath.pushContainer(
+          'specifiers',
+          t.importSpecifier(t.identifier(identifierName), t.identifier('c')),
+        );
+        didInsertUseMemoCache = true;
+      }
+    },
+  });
+  return didInsertUseMemoCache;
+}
+
+export function updateMemoCacheFunctionImport(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  useMemoCacheIdentifier: string,
+): void {
+  /*
+   * If there isn't already an import of * as React, insert it so useMemoCache doesn't
+   * throw
+   */
+  const hasExistingImport = hasExistingNonNamespacedImportOfModule(
+    program,
+    moduleName,
+  );
+
+  if (hasExistingImport) {
+    const didUpdateImport = addMemoCacheFunctionSpecifierToExistingImport(
+      program,
+      moduleName,
+      useMemoCacheIdentifier,
+    );
+    if (!didUpdateImport) {
+      throw new Error(
+        `Expected an ImportDeclaration of \`${moduleName}\` in order to update ImportSpecifiers with useMemoCache`,
+      );
+    }
+  } else {
+    addMemoCacheFunctionImportDeclaration(
+      program,
+      moduleName,
+      useMemoCacheIdentifier,
+    );
+  }
+}
+
+function addMemoCacheFunctionImportDeclaration(
+  program: NodePath<t.Program>,
+  moduleName: string,
+  localName: string,
+): void {
+  program.unshiftContainer(
+    'body',
+    t.importDeclaration(
+      [t.importSpecifier(t.identifier(localName), t.identifier('c'))],
+      t.stringLiteral(moduleName),
+    ),
+  );
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
@@ -7,12 +7,7 @@

 import * as t from '@babel/types';
 import {z} from 'zod';
-import {
-  CompilerDiagnostic,
-  CompilerError,
-  CompilerErrorDetail,
-  CompilerErrorDetailOptions,
-} from '../CompilerError';
+import {CompilerError, CompilerErrorDetailOptions} from '../CompilerError';
 import {
  EnvironmentConfig,
  ExternalFunction,
@@ -42,14 +37,6 @@ const PanicThresholdOptionsSchema = z.enum([
 ]);

 export type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
-const DynamicGatingOptionsSchema = z.object({
-  source: z.string(),
-});
-export type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
-const CustomOptOutDirectiveSchema = z
-  .nullable(z.array(z.string()))
-  .default(null);
-type CustomOptOutDirective = z.infer<typeof CustomOptOutDirectiveSchema>;

 export type PluginOptions = {
  environment: EnvironmentConfig;
@@ -78,28 +65,6 @@ export type PluginOptions = {
   */
  gating: ExternalFunction | null;

-  /**
-   * If specified, this enables dynamic gating which matches `use memo if(...)`
-   * directives.
-   *
-   * Example usage:
-   * ```js
-   * // @dynamicGating:{"source":"myModule"}
-   * export function MyComponent() {
-   *   'use memo if(isEnabled)';
-   *    return <div>...</div>;
-   * }
-   * ```
-   * This will emit:
-   * ```js
-   * import {isEnabled} from 'myModule';
-   * export const MyComponent = isEnabled()
-   *   ? <optimized version>
-   *   : <original version>;
-   * ```
-   */
-  dynamicGating: DynamicGatingOptions | null;
-
  panicThreshold: PanicThresholdOptions;

  /*
@@ -133,7 +98,7 @@ export type PluginOptions = {
   * provided rules will skip compilation. To disable this feature (never bailout of compilation
   * even if the default ESLint is suppressed), pass an empty array.
   */
-  eslintSuppressionRules: Array<string> | null | undefined;
+  eslintSuppressionRules?: Array<string> | null | undefined;

  flowSuppressions: boolean;
  /*
@@ -141,12 +106,7 @@ export type PluginOptions = {
   */
  ignoreUseNoForget: boolean;

-  /**
-   * Unstable / do not use
-   */
-  customOptOutDirectives: CustomOptOutDirective;
-
-  sources: Array<string> | ((filename: string) => boolean) | null;
+  sources?: Array<string> | ((filename: string) => boolean) | null;

  /**
   * The compiler has customized support for react-native-reanimated, intended as a temporary workaround.
@@ -222,14 +182,12 @@ export type LoggerEvent =
  | CompileDiagnosticEvent
  | CompileSkipEvent
  | PipelineErrorEvent
-  | TimingEvent
-  | AutoDepsDecorationsEvent
-  | AutoDepsEligibleEvent;
+  | TimingEvent;

 export type CompileErrorEvent = {
  kind: 'CompileError';
  fnLoc: t.SourceLocation | null;
-  detail: CompilerErrorDetail | CompilerDiagnostic;
+  detail: CompilerErrorDetailOptions;
 };
 export type CompileDiagnosticEvent = {
  kind: 'CompileDiagnostic';
@@ -261,16 +219,6 @@ export type TimingEvent = {
  kind: 'Timing';
  measurement: PerformanceMeasure;
 };
-export type AutoDepsDecorationsEvent = {
-  kind: 'AutoDepsDecorations';
-  fnLoc: t.SourceLocation;
-  decorations: Array<t.SourceLocation>;
-};
-export type AutoDepsEligibleEvent = {
-  kind: 'AutoDepsEligible';
-  fnLoc: t.SourceLocation;
-  depArrayLoc: t.SourceLocation;
-};

 export type Logger = {
  logEvent: (filename: string | null, event: LoggerEvent) => void;
@@ -284,7 +232,6 @@ export const defaultOptions: PluginOptions = {
  logger: null,
  gating: null,
  noEmit: false,
-  dynamicGating: null,
  eslintSuppressionRules: null,
  flowSuppressions: true,
  ignoreUseNoForget: false,
@@ -292,7 +239,6 @@ export const defaultOptions: PluginOptions = {
    return filename.indexOf('node_modules') === -1;
  },
  enableReanimatedCheck: true,
-  customOptOutDirectives: null,
  target: '19',
 } as const;

@@ -334,40 +280,6 @@ export function parsePluginOptions(obj: unknown): PluginOptions {
          }
          break;
        }
-        case 'dynamicGating': {
-          if (value == null) {
-            parsedOptions[key] = null;
-          } else {
-            const result = DynamicGatingOptionsSchema.safeParse(value);
-            if (result.success) {
-              parsedOptions[key] = result.data;
-            } else {
-              CompilerError.throwInvalidConfig({
-                reason:
-                  'Could not parse dynamic gating. Update React Compiler config to fix the error',
-                description: `${fromZodError(result.error)}`,
-                loc: null,
-                suggestions: null,
-              });
-            }
-          }
-          break;
-        }
-        case 'customOptOutDirectives': {
-          const result = CustomOptOutDirectiveSchema.safeParse(value);
-          if (result.success) {
-            parsedOptions[key] = result.data;
-          } else {
-            CompilerError.throwInvalidConfig({
-              reason:
-                'Could not parse custom opt out directives. Update React Compiler config to fix the error',
-              description: `${fromZodError(result.error)}`,
-              loc: null,
-              suggestions: null,
-            });
-          }
-          break;
-        }
        default: {
          parsedOptions[key] = value;
        }
--- 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 {Logger, ProgramContext} from '.';
+import {Logger} from '.';
 import {
  HIRFunction,
  ReactiveFunction,
@@ -33,7 +33,9 @@ import {findContextIdentifiers} from '../HIR/FindContextIdentifiers';
 import {
  analyseFunctions,
  dropManualMemoization,
+  inferMutableRanges,
  inferReactivePlaces,
+  inferReferenceEffects,
  inlineImmediatelyInvokedFunctionExpressions,
  inferEffectDependencies,
 } from '../Inference';
@@ -90,19 +92,16 @@ import {
 } from '../Validation';
 import {validateLocalsNotReassignedAfterRender} from '../Validation/ValidateLocalsNotReassignedAfterRender';
 import {outlineFunctions} from '../Optimization/OutlineFunctions';
+import {propagatePhiTypes} from '../TypeInference/PropagatePhiTypes';
 import {lowerContextAccess} from '../Optimization/LowerContextAccess';
-import {validateNoSetStateInEffects} from '../Validation/ValidateNoSetStateInEffects';
+import {validateNoSetStateInPassiveEffects} from '../Validation/ValidateNoSetStateInPassiveEffects';
 import {validateNoJSXInTryStatement} from '../Validation/ValidateNoJSXInTryStatement';
 import {propagateScopeDependenciesHIR} from '../HIR/PropagateScopeDependenciesHIR';
 import {outlineJSX} from '../Optimization/OutlineJsx';
 import {optimizePropsMethodCalls} from '../Optimization/OptimizePropsMethodCalls';
 import {transformFire} from '../Transform';
-import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureFunctionsInRender';
-import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
-import {validateNoFreezingKnownMutableFunctions} from '../Validation/ValidateNoFreezingKnownMutableFunctions';
-import {inferMutationAliasingEffects} from '../Inference/InferMutationAliasingEffects';
-import {inferMutationAliasingRanges} from '../Inference/InferMutationAliasingRanges';
-import {validateNoDerivedComputationsInEffects} from '../Validation/ValidateNoDerivedComputationsInEffects';
+import {validateNoImpureFunctionsInRender} from '../Validation/ValiateNoImpureFunctionsInRender';
+import {CompilerError} from '..';

 export type CompilerPipelineValue =
  | {kind: 'ast'; name: string; value: CodegenFunction}
@@ -117,7 +116,7 @@ function run(
  config: EnvironmentConfig,
  fnType: ReactFunctionType,
  mode: CompilerMode,
-  programContext: ProgramContext,
+  useMemoCacheIdentifier: string,
  logger: Logger | null,
  filename: string | null,
  code: string | null,
@@ -129,11 +128,10 @@ function run(
    mode,
    config,
    contextIdentifiers,
-    func,
    logger,
    filename,
    code,
-    programContext,
+    useMemoCacheIdentifier,
  );
  env.logger?.debugLogIRs?.({
    kind: 'debug',
@@ -163,7 +161,7 @@ function runWithEnvironment(
  log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});

  validateContextVariableLValues(hir);
-  validateUseMemo(hir).unwrap();
+  validateUseMemo(hir);

  if (
    env.isInferredMemoEnabled &&
@@ -171,7 +169,7 @@ function runWithEnvironment(
    !env.config.disableMemoizationForDebugging &&
    !env.config.enableChangeDetectionForDebugging
  ) {
-    dropManualMemoization(hir).unwrap();
+    dropManualMemoization(hir);
    log({kind: 'hir', name: 'DropManualMemoization', value: hir});
  }

@@ -204,10 +202,10 @@ function runWithEnvironment(

  if (env.isInferredMemoEnabled) {
    if (env.config.validateHooksUsage) {
-      validateHooksUsage(hir).unwrap();
+      validateHooksUsage(hir);
    }
    if (env.config.validateNoCapitalizedCalls) {
-      validateNoCapitalizedCalls(hir).unwrap();
+      validateNoCapitalizedCalls(hir);
    }
  }

@@ -226,13 +224,15 @@ function runWithEnvironment(
  analyseFunctions(hir);
  log({kind: 'hir', name: 'AnalyseFunctions', value: hir});

-  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
-  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+  const fnEffectErrors = inferReferenceEffects(hir);
  if (env.isInferredMemoEnabled) {
-    if (mutabilityAliasingErrors.isErr()) {
-      throw mutabilityAliasingErrors.unwrapErr();
+    if (fnEffectErrors.length > 0) {
+      CompilerError.throw(fnEffectErrors[0]);
    }
  }
+  log({kind: 'hir', name: 'InferReferenceEffects', value: hir});
+
+  validateLocalsNotReassignedAfterRender(hir);

  // Note: Has to come after infer reference effects because "dead" code may still affect inference
  deadCodeElimination(hir);
@@ -246,16 +246,8 @@ function runWithEnvironment(
  pruneMaybeThrows(hir);
  log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});

-  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
-    isFunctionExpression: false,
-  });
-  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
-  if (env.isInferredMemoEnabled) {
-    if (mutabilityAliasingRangeErrors.isErr()) {
-      throw mutabilityAliasingRangeErrors.unwrapErr();
-    }
-    validateLocalsNotReassignedAfterRender(hir);
-  }
+  inferMutableRanges(hir);
+  log({kind: 'hir', name: 'InferMutableRanges', value: hir});

  if (env.isInferredMemoEnabled) {
    if (env.config.assertValidMutableRanges) {
@@ -263,30 +255,24 @@ function runWithEnvironment(
    }

    if (env.config.validateRefAccessDuringRender) {
-      validateNoRefAccessInRender(hir).unwrap();
+      validateNoRefAccessInRender(hir);
    }

    if (env.config.validateNoSetStateInRender) {
-      validateNoSetStateInRender(hir).unwrap();
+      validateNoSetStateInRender(hir);
    }

-    if (env.config.validateNoDerivedComputationsInEffects) {
-      validateNoDerivedComputationsInEffects(hir);
-    }
-
-    if (env.config.validateNoSetStateInEffects) {
-      env.logErrors(validateNoSetStateInEffects(hir));
+    if (env.config.validateNoSetStateInPassiveEffects) {
+      validateNoSetStateInPassiveEffects(hir);
    }

    if (env.config.validateNoJSXInTryStatements) {
-      env.logErrors(validateNoJSXInTryStatement(hir));
+      validateNoJSXInTryStatement(hir);
    }

    if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir).unwrap();
+      validateNoImpureFunctionsInRender(hir);
    }
-
-    validateNoFreezingKnownMutableFunctions(hir).unwrap();
  }

  inferReactivePlaces(hir);
@@ -299,11 +285,14 @@ function runWithEnvironment(
    value: hir,
  });

-  if (env.isInferredMemoEnabled) {
-    if (env.config.validateStaticComponents) {
-      env.logErrors(validateStaticComponents(hir));
-    }
+  propagatePhiTypes(hir);
+  log({
+    kind: 'hir',
+    name: 'PropagatePhiTypes',
+    value: hir,
+  });

+  if (env.isInferredMemoEnabled) {
    /**
     * Only create reactive scopes (which directly map to generated memo blocks)
     * if inferred memoization is enabled. This makes all later passes which
@@ -398,11 +387,6 @@ function runWithEnvironment(

  if (env.config.inferEffectDependencies) {
    inferEffectDependencies(hir);
-    log({
-      kind: 'hir',
-      name: 'InferEffectDependencies',
-      value: hir,
-    });
  }

  if (env.config.inlineJsxTransform) {
@@ -525,14 +509,14 @@ function runWithEnvironment(
  });

  if (env.config.validateMemoizedEffectDependencies) {
-    validateMemoizedEffectDependencies(reactiveFunction).unwrap();
+    validateMemoizedEffectDependencies(reactiveFunction);
  }

  if (
    env.config.enablePreserveExistingMemoizationGuarantees ||
    env.config.validatePreserveExistingMemoizationGuarantees
  ) {
-    validatePreservedManualMemoization(reactiveFunction).unwrap();
+    validatePreservedManualMemoization(reactiveFunction);
  }

  const ast = codegenFunction(reactiveFunction, {
@@ -563,7 +547,7 @@ export function compileFn(
  config: EnvironmentConfig,
  fnType: ReactFunctionType,
  mode: CompilerMode,
-  programContext: ProgramContext,
+  useMemoCacheIdentifier: string,
  logger: Logger | null,
  filename: string | null,
  code: string | null,
@@ -573,7 +557,7 @@ export function compileFn(
    config,
    fnType,
    mode,
-    programContext,
+    useMemoCacheIdentifier,
    logger,
    filename,
    code,
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Reanimated.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Reanimated.ts
@@ -1,10 +1,3 @@
-/**
- * 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 type * as BabelCore from '@babel/core';
 import {hasOwnProperty} from '../Utils/utils';
 import {PluginOptions} from './Options';
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Suppression.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Suppression.ts
@@ -8,10 +8,9 @@
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
 import {
-  CompilerDiagnostic,
  CompilerError,
+  CompilerErrorDetail,
  CompilerSuggestionOperation,
-  ErrorCategory,
  ErrorSeverity,
 } from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
@@ -182,12 +181,12 @@ export function suppressionsToCompilerError(
          'Unhandled suppression source',
        );
    }
-    error.pushDiagnostic(
-      CompilerDiagnostic.create({
-        reason: reason,
-        description: `React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression \`${suppressionRange.disableComment.value.trim()}\``,
+    error.pushErrorDetail(
+      new CompilerErrorDetail({
+        reason: `${reason}. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior`,
+        description: suppressionRange.disableComment.value.trim(),
        severity: ErrorSeverity.InvalidReact,
-        category: ErrorCategory.Suppression,
+        loc: suppressionRange.disableComment.loc ?? null,
        suggestions: [
          {
            description: suggestion,
@@ -198,10 +197,6 @@ export function suppressionsToCompilerError(
            op: CompilerSuggestionOperation.Remove,
          },
        ],
-      }).withDetail({
-        kind: 'error',
-        loc: suppressionRange.disableComment.loc ?? null,
-        message: 'Found React rule suppression',
      }),
    );
  }
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/ValidateNoUntransformedReferences.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/ValidateNoUntransformedReferences.ts
@@ -1,74 +1,34 @@
-/**
- * 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/core';
 import * as t from '@babel/types';

-import {CompilerError, EnvironmentConfig, ErrorSeverity, Logger} from '..';
-import {getOrInsertWith} from '../Utils/utils';
-import {Environment, GeneratedSource} from '../HIR';
-import {DEFAULT_EXPORT} from '../HIR/Environment';
-import {CompileProgramMetadata} from './Program';
 import {
-  CompilerDiagnostic,
-  CompilerDiagnosticOptions,
-  ErrorCategory,
-} from '../CompilerError';
+  CompilerError,
+  CompilerErrorDetailOptions,
+  EnvironmentConfig,
+  ErrorSeverity,
+  Logger,
+} from '..';
+import {getOrInsertWith} from '../Utils/utils';
+import {Environment} from '../HIR';
+import {DEFAULT_EXPORT} from '../HIR/Environment';

 function throwInvalidReact(
-  options: Omit<CompilerDiagnosticOptions, 'severity'>,
+  options: Omit<CompilerErrorDetailOptions, 'severity'>,
  {logger, filename}: TraversalState,
 ): never {
-  const detail: CompilerDiagnosticOptions = {
-    severity: ErrorSeverity.InvalidReact,
+  const detail: CompilerErrorDetailOptions = {
    ...options,
+    severity: ErrorSeverity.InvalidReact,
  };
  logger?.logEvent(filename, {
    kind: 'CompileError',
    fnLoc: null,
-    detail: new CompilerDiagnostic(detail),
+    detail,
  });
-  CompilerError.throwDiagnostic(detail);
-}
-
-function isAutodepsSigil(
-  arg: NodePath<t.ArgumentPlaceholder | t.SpreadElement | t.Expression>,
-): boolean {
-  // Check for AUTODEPS identifier imported from React
-  if (arg.isIdentifier() && arg.node.name === 'AUTODEPS') {
-    const binding = arg.scope.getBinding(arg.node.name);
-    if (binding && binding.path.isImportSpecifier()) {
-      const importSpecifier = binding.path.node as t.ImportSpecifier;
-      if (importSpecifier.imported.type === 'Identifier') {
-        return (importSpecifier.imported as t.Identifier).name === 'AUTODEPS';
-      }
-    }
-    return false;
-  }
-
-  // Check for React.AUTODEPS member expression
-  if (arg.isMemberExpression() && !arg.node.computed) {
-    const object = arg.get('object');
-    const property = arg.get('property');
-
-    if (
-      object.isIdentifier() &&
-      object.node.name === 'React' &&
-      property.isIdentifier() &&
-      property.node.name === 'AUTODEPS'
-    ) {
-      return true;
-    }
-  }
-
-  return false;
+  CompilerError.throw(detail);
 }
 function assertValidEffectImportReference(
-  autodepsIndex: number,
+  numArgs: number,
  paths: Array<NodePath<t.Node>>,
  context: TraversalState,
 ): void {
@@ -76,15 +36,12 @@ function assertValidEffectImportReference(
    const parent = path.parentPath;
    if (parent != null && parent.isCallExpression()) {
      const args = parent.get('arguments');
-      const maybeCalleeLoc = path.node.loc;
-      const hasInferredEffect =
-        maybeCalleeLoc != null &&
-        context.inferredEffectLocations.has(maybeCalleeLoc);
      /**
-       * Error on effect calls that still have AUTODEPS in their args
+       * Only error on untransformed references of the form `useMyEffect(...)`
+       * or `moduleNamespace.useMyEffect(...)`, with matching argument counts.
+       * TODO: do we also want a mode to also hard error on non-call references?
       */
-      const hasAutodepsArg = args.some(isAutodepsSigil);
-      if (hasAutodepsArg && !hasInferredEffect) {
+      if (args.length === numArgs) {
        const maybeErrorDiagnostic = matchCompilerDiagnostic(
          path,
          context.transformErrors,
@@ -96,19 +53,14 @@ function assertValidEffectImportReference(
         */
        throwInvalidReact(
          {
-            category: ErrorCategory.AutomaticEffectDependencies,
            reason:
-              'Cannot infer dependencies of this effect. This will break your build!',
-            description:
-              'To resolve, either pass a dependency array or fix reported compiler bailout diagnostics.' +
-              (maybeErrorDiagnostic ? ` ${maybeErrorDiagnostic}` : ''),
-            details: [
-              {
-                kind: 'error',
-                message: 'Cannot infer dependencies',
-                loc: parent.node.loc ?? GeneratedSource,
-              },
-            ],
+              '[InferEffectDependencies] React Compiler is unable to infer dependencies of this effect. ' +
+              'This will break your build! ' +
+              'To resolve, either pass your own dependency array or fix reported compiler bailout diagnostics.',
+            description: maybeErrorDiagnostic
+              ? `(Bailout reason: ${maybeErrorDiagnostic})`
+              : null,
+            loc: parent.node.loc ?? null,
          },
          context,
        );
@@ -128,20 +80,13 @@ function assertValidFireImportReference(
    );
    throwInvalidReact(
      {
-        category: ErrorCategory.Fire,
-        reason: '[Fire] Untransformed reference to compiler-required feature.',
-        description:
-          'Either remove this `fire` call or ensure it is successfully transformed by the compiler' +
-          maybeErrorDiagnostic
-            ? ` ${maybeErrorDiagnostic}`
-            : '',
-        details: [
-          {
-            kind: 'error',
-            message: 'Untransformed `fire` call',
-            loc: paths[0].node.loc ?? GeneratedSource,
-          },
-        ],
+        reason:
+          '[Fire] Untransformed reference to compiler-required feature. ' +
+          'Either remove this `fire` call or ensure it is successfully transformed by the compiler',
+        description: maybeErrorDiagnostic
+          ? `(Bailout reason: ${maybeErrorDiagnostic})`
+          : null,
+        loc: paths[0].node.loc ?? null,
      },
      context,
    );
@@ -152,7 +97,7 @@ export default function validateNoUntransformedReferences(
  filename: string | null,
  logger: Logger | null,
  env: EnvironmentConfig,
-  compileResult: CompileProgramMetadata | null,
+  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>,
 ): void {
  const moduleLoadChecks = new Map<
    string,
@@ -171,17 +116,17 @@ export default function validateNoUntransformedReferences(
  if (env.inferEffectDependencies) {
    for (const {
      function: {source, importSpecifierName},
-      autodepsIndex,
+      numRequiredArgs,
    } of env.inferEffectDependencies) {
      const module = getOrInsertWith(moduleLoadChecks, source, () => new Map());
      module.set(
        importSpecifierName,
-        assertValidEffectImportReference.bind(null, autodepsIndex),
+        assertValidEffectImportReference.bind(null, numRequiredArgs),
      );
    }
  }
  if (moduleLoadChecks.size > 0) {
-    transformProgram(path, moduleLoadChecks, filename, logger, compileResult);
+    transformProgram(path, moduleLoadChecks, filename, logger, transformErrors);
  }
 }

@@ -191,7 +136,6 @@ type TraversalState = {
  logger: Logger | null;
  filename: string | null;
  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>;
-  inferredEffectLocations: Set<t.SourceLocation>;
 };
 type CheckInvalidReferenceFn = (
  paths: Array<NodePath<t.Node>>,
@@ -279,16 +223,14 @@ function transformProgram(
  moduleLoadChecks: Map<string, Map<string, CheckInvalidReferenceFn>>,
  filename: string | null,
  logger: Logger | null,
-  compileResult: CompileProgramMetadata | null,
+  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>,
 ): void {
  const traversalState: TraversalState = {
    shouldInvalidateScopes: true,
    program: path,
    filename,
    logger,
-    transformErrors: compileResult?.retryErrors ?? [],
-    inferredEffectLocations:
-      compileResult?.inferredEffectLocations ?? new Set(),
+    transformErrors,
  };
  path.traverse({
    ImportDeclaration(path: NodePath<t.ImportDeclaration>) {
--- a/compiler/packages/babel-plugin-react-compiler/src/Flood/FlowTypes.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Flood/FlowTypes.ts
@@ -1,752 +0,0 @@
-/**
- * TypeScript definitions for Flow type JSON representations
- * Based on the output of /data/sandcastle/boxes/fbsource/fbcode/flow/src/typing/convertTypes.ml
- */
-
-// Base type for all Flow types with a kind field
-export interface BaseFlowType {
-  kind: string;
-}
-
-// Type for representing polarity
-export type Polarity = 'positive' | 'negative' | 'neutral';
-
-// Type for representing a name that might be null
-export type OptionalName = string | null;
-
-// Open type
-export interface OpenType extends BaseFlowType {
-  kind: 'Open';
-}
-
-// Def type
-export interface DefType extends BaseFlowType {
-  kind: 'Def';
-  def: DefT;
-}
-
-// Eval type
-export interface EvalType extends BaseFlowType {
-  kind: 'Eval';
-  type: FlowType;
-  destructor: Destructor;
-}
-
-// Generic type
-export interface GenericType extends BaseFlowType {
-  kind: 'Generic';
-  name: string;
-  bound: FlowType;
-  no_infer: boolean;
-}
-
-// ThisInstance type
-export interface ThisInstanceType extends BaseFlowType {
-  kind: 'ThisInstance';
-  instance: InstanceT;
-  is_this: boolean;
-  name: string;
-}
-
-// ThisTypeApp type
-export interface ThisTypeAppType extends BaseFlowType {
-  kind: 'ThisTypeApp';
-  t1: FlowType;
-  t2: FlowType;
-  t_list?: Array<FlowType>;
-}
-
-// TypeApp type
-export interface TypeAppType extends BaseFlowType {
-  kind: 'TypeApp';
-  type: FlowType;
-  targs: Array<FlowType>;
-  from_value: boolean;
-  use_desc: boolean;
-}
-
-// FunProto type
-export interface FunProtoType extends BaseFlowType {
-  kind: 'FunProto';
-}
-
-// ObjProto type
-export interface ObjProtoType extends BaseFlowType {
-  kind: 'ObjProto';
-}
-
-// NullProto type
-export interface NullProtoType extends BaseFlowType {
-  kind: 'NullProto';
-}
-
-// FunProtoBind type
-export interface FunProtoBindType extends BaseFlowType {
-  kind: 'FunProtoBind';
-}
-
-// Intersection type
-export interface IntersectionType extends BaseFlowType {
-  kind: 'Intersection';
-  members: Array<FlowType>;
-}
-
-// Union type
-export interface UnionType extends BaseFlowType {
-  kind: 'Union';
-  members: Array<FlowType>;
-}
-
-// Maybe type
-export interface MaybeType extends BaseFlowType {
-  kind: 'Maybe';
-  type: FlowType;
-}
-
-// Optional type
-export interface OptionalType extends BaseFlowType {
-  kind: 'Optional';
-  type: FlowType;
-  use_desc: boolean;
-}
-
-// Keys type
-export interface KeysType extends BaseFlowType {
-  kind: 'Keys';
-  type: FlowType;
-}
-
-// Annot type
-export interface AnnotType extends BaseFlowType {
-  kind: 'Annot';
-  type: FlowType;
-  use_desc: boolean;
-}
-
-// Opaque type
-export interface OpaqueType extends BaseFlowType {
-  kind: 'Opaque';
-  opaquetype: {
-    opaque_id: string;
-    underlying_t: FlowType | null;
-    super_t: FlowType | null;
-    opaque_type_args: Array<{
-      name: string;
-      type: FlowType;
-      polarity: Polarity;
-    }>;
-    opaque_name: string;
-  };
-}
-
-// Namespace type
-export interface NamespaceType extends BaseFlowType {
-  kind: 'Namespace';
-  namespace_symbol: {
-    symbol: string;
-  };
-  values_type: FlowType;
-  types_tmap: PropertyMap;
-}
-
-// Any type
-export interface AnyType extends BaseFlowType {
-  kind: 'Any';
-}
-
-// StrUtil type
-export interface StrUtilType extends BaseFlowType {
-  kind: 'StrUtil';
-  op: 'StrPrefix' | 'StrSuffix';
-  prefix?: string;
-  suffix?: string;
-  remainder?: FlowType;
-}
-
-// TypeParam definition
-export interface TypeParam {
-  name: string;
-  bound: FlowType;
-  polarity: Polarity;
-  default: FlowType | null;
-}
-
-// EnumInfo types
-export type EnumInfo = ConcreteEnum | AbstractEnum;
-
-export interface ConcreteEnum {
-  kind: 'ConcreteEnum';
-  enum_name: string;
-  enum_id: string;
-  members: Array<string>;
-  representation_t: FlowType;
-  has_unknown_members: boolean;
-}
-
-export interface AbstractEnum {
-  kind: 'AbstractEnum';
-  representation_t: FlowType;
-}
-
-// CanonicalRendersForm types
-export type CanonicalRendersForm =
-  | InstrinsicRenders
-  | NominalRenders
-  | StructuralRenders
-  | DefaultRenders;
-
-export interface InstrinsicRenders {
-  kind: 'InstrinsicRenders';
-  name: string;
-}
-
-export interface NominalRenders {
-  kind: 'NominalRenders';
-  renders_id: string;
-  renders_name: string;
-  renders_super: FlowType;
-}
-
-export interface StructuralRenders {
-  kind: 'StructuralRenders';
-  renders_variant: 'RendersNormal' | 'RendersMaybe' | 'RendersStar';
-  renders_structural_type: FlowType;
-}
-
-export interface DefaultRenders {
-  kind: 'DefaultRenders';
-}
-
-// InstanceT definition
-export interface InstanceT {
-  inst: InstType;
-  static: FlowType;
-  super: FlowType;
-  implements: Array<FlowType>;
-}
-
-// InstType definition
-export interface InstType {
-  class_name: string | null;
-  class_id: string;
-  type_args: Array<{
-    name: string;
-    type: FlowType;
-    polarity: Polarity;
-  }>;
-  own_props: PropertyMap;
-  proto_props: PropertyMap;
-  call_t: null | {
-    id: number;
-    call: FlowType;
-  };
-}
-
-// DefT types
-export type DefT =
-  | NumGeneralType
-  | StrGeneralType
-  | BoolGeneralType
-  | BigIntGeneralType
-  | EmptyType
-  | MixedType
-  | NullType
-  | VoidType
-  | SymbolType
-  | FunType
-  | ObjType
-  | ArrType
-  | ClassType
-  | InstanceType
-  | SingletonStrType
-  | NumericStrKeyType
-  | SingletonNumType
-  | SingletonBoolType
-  | SingletonBigIntType
-  | TypeType
-  | PolyType
-  | ReactAbstractComponentType
-  | RendersType
-  | EnumValueType
-  | EnumObjectType;
-
-export interface NumGeneralType extends BaseFlowType {
-  kind: 'NumGeneral';
-}
-
-export interface StrGeneralType extends BaseFlowType {
-  kind: 'StrGeneral';
-}
-
-export interface BoolGeneralType extends BaseFlowType {
-  kind: 'BoolGeneral';
-}
-
-export interface BigIntGeneralType extends BaseFlowType {
-  kind: 'BigIntGeneral';
-}
-
-export interface EmptyType extends BaseFlowType {
-  kind: 'Empty';
-}
-
-export interface MixedType extends BaseFlowType {
-  kind: 'Mixed';
-}
-
-export interface NullType extends BaseFlowType {
-  kind: 'Null';
-}
-
-export interface VoidType extends BaseFlowType {
-  kind: 'Void';
-}
-
-export interface SymbolType extends BaseFlowType {
-  kind: 'Symbol';
-}
-
-export interface FunType extends BaseFlowType {
-  kind: 'Fun';
-  static: FlowType;
-  funtype: FunTypeObj;
-}
-
-export interface ObjType extends BaseFlowType {
-  kind: 'Obj';
-  objtype: ObjTypeObj;
-}
-
-export interface ArrType extends BaseFlowType {
-  kind: 'Arr';
-  arrtype: ArrTypeObj;
-}
-
-export interface ClassType extends BaseFlowType {
-  kind: 'Class';
-  type: FlowType;
-}
-
-export interface InstanceType extends BaseFlowType {
-  kind: 'Instance';
-  instance: InstanceT;
-}
-
-export interface SingletonStrType extends BaseFlowType {
-  kind: 'SingletonStr';
-  from_annot: boolean;
-  value: string;
-}
-
-export interface NumericStrKeyType extends BaseFlowType {
-  kind: 'NumericStrKey';
-  number: string;
-  string: string;
-}
-
-export interface SingletonNumType extends BaseFlowType {
-  kind: 'SingletonNum';
-  from_annot: boolean;
-  number: string;
-  string: string;
-}
-
-export interface SingletonBoolType extends BaseFlowType {
-  kind: 'SingletonBool';
-  from_annot: boolean;
-  value: boolean;
-}
-
-export interface SingletonBigIntType extends BaseFlowType {
-  kind: 'SingletonBigInt';
-  from_annot: boolean;
-  value: string;
-}
-
-export interface TypeType extends BaseFlowType {
-  kind: 'Type';
-  type_kind: TypeTKind;
-  type: FlowType;
-}
-
-export type TypeTKind =
-  | 'TypeAliasKind'
-  | 'TypeParamKind'
-  | 'OpaqueKind'
-  | 'ImportTypeofKind'
-  | 'ImportClassKind'
-  | 'ImportEnumKind'
-  | 'InstanceKind'
-  | 'RenderTypeKind';
-
-export interface PolyType extends BaseFlowType {
-  kind: 'Poly';
-  tparams: Array<TypeParam>;
-  t_out: FlowType;
-  id: string;
-}
-
-export interface ReactAbstractComponentType extends BaseFlowType {
-  kind: 'ReactAbstractComponent';
-  config: FlowType;
-  renders: FlowType;
-  instance: ComponentInstance;
-  component_kind: ComponentKind;
-}
-
-export type ComponentInstance =
-  | {kind: 'RefSetterProp'; type: FlowType}
-  | {kind: 'Omitted'};
-
-export type ComponentKind =
-  | {kind: 'Structural'}
-  | {kind: 'Nominal'; id: string; name: string; types: Array<FlowType> | null};
-
-export interface RendersType extends BaseFlowType {
-  kind: 'Renders';
-  form: CanonicalRendersForm;
-}
-
-export interface EnumValueType extends BaseFlowType {
-  kind: 'EnumValue';
-  enum_info: EnumInfo;
-}
-
-export interface EnumObjectType extends BaseFlowType {
-  kind: 'EnumObject';
-  enum_value_t: FlowType;
-  enum_info: EnumInfo;
-}
-
-// ObjKind types
-export type ObjKind =
-  | {kind: 'Exact'}
-  | {kind: 'Inexact'}
-  | {kind: 'Indexed'; dicttype: DictType};
-
-// DictType definition
-export interface DictType {
-  dict_name: string | null;
-  key: FlowType;
-  value: FlowType;
-  dict_polarity: Polarity;
-}
-
-// ArrType types
-export type ArrTypeObj = ArrayAT | TupleAT | ROArrayAT;
-
-export interface ArrayAT {
-  kind: 'ArrayAT';
-  elem_t: FlowType;
-}
-
-export interface TupleAT {
-  kind: 'TupleAT';
-  elem_t: FlowType;
-  elements: Array<TupleElement>;
-  min_arity: number;
-  max_arity: number;
-  inexact: boolean;
-}
-
-export interface ROArrayAT {
-  kind: 'ROArrayAT';
-  elem_t: FlowType;
-}
-
-// TupleElement definition
-export interface TupleElement {
-  name: string | null;
-  t: FlowType;
-  polarity: Polarity;
-  optional: boolean;
-}
-
-// Flags definition
-export interface Flags {
-  obj_kind: ObjKind;
-}
-
-// Property types
-export type Property =
-  | FieldProperty
-  | GetProperty
-  | SetProperty
-  | GetSetProperty
-  | MethodProperty;
-
-export interface FieldProperty {
-  kind: 'Field';
-  type: FlowType;
-  polarity: Polarity;
-}
-
-export interface GetProperty {
-  kind: 'Get';
-  type: FlowType;
-}
-
-export interface SetProperty {
-  kind: 'Set';
-  type: FlowType;
-}
-
-export interface GetSetProperty {
-  kind: 'GetSet';
-  get_type: FlowType;
-  set_type: FlowType;
-}
-
-export interface MethodProperty {
-  kind: 'Method';
-  type: FlowType;
-}
-
-// PropertyMap definition
-export interface PropertyMap {
-  [key: string]: Property; // For other properties in the map
-}
-
-// ObjType definition
-export interface ObjTypeObj {
-  flags: Flags;
-  props: PropertyMap;
-  proto_t: FlowType;
-  call_t: number | null;
-}
-
-// FunType definition
-export interface FunTypeObj {
-  this_t: {
-    type: FlowType;
-    status: ThisStatus;
-  };
-  params: Array<{
-    name: string | null;
-    type: FlowType;
-  }>;
-  rest_param: null | {
-    name: string | null;
-    type: FlowType;
-  };
-  return_t: FlowType;
-  type_guard: null | {
-    inferred: boolean;
-    param_name: string;
-    type_guard: FlowType;
-    one_sided: boolean;
-  };
-  effect: Effect;
-}
-
-// ThisStatus types
-export type ThisStatus =
-  | {kind: 'This_Method'; unbound: boolean}
-  | {kind: 'This_Function'};
-
-// Effect types
-export type Effect =
-  | {kind: 'HookDecl'; id: string}
-  | {kind: 'HookAnnot'}
-  | {kind: 'ArbitraryEffect'}
-  | {kind: 'AnyEffect'};
-
-// Destructor types
-export type Destructor =
-  | NonMaybeTypeDestructor
-  | PropertyTypeDestructor
-  | ElementTypeDestructor
-  | OptionalIndexedAccessNonMaybeTypeDestructor
-  | OptionalIndexedAccessResultTypeDestructor
-  | ExactTypeDestructor
-  | ReadOnlyTypeDestructor
-  | PartialTypeDestructor
-  | RequiredTypeDestructor
-  | SpreadTypeDestructor
-  | SpreadTupleTypeDestructor
-  | RestTypeDestructor
-  | ValuesTypeDestructor
-  | ConditionalTypeDestructor
-  | TypeMapDestructor
-  | ReactElementPropsTypeDestructor
-  | ReactElementConfigTypeDestructor
-  | ReactCheckComponentConfigDestructor
-  | ReactDRODestructor
-  | MakeHooklikeDestructor
-  | MappedTypeDestructor
-  | EnumTypeDestructor;
-
-export interface NonMaybeTypeDestructor {
-  kind: 'NonMaybeType';
-}
-
-export interface PropertyTypeDestructor {
-  kind: 'PropertyType';
-  name: string;
-}
-
-export interface ElementTypeDestructor {
-  kind: 'ElementType';
-  index_type: FlowType;
-}
-
-export interface OptionalIndexedAccessNonMaybeTypeDestructor {
-  kind: 'OptionalIndexedAccessNonMaybeType';
-  index: OptionalIndexedAccessIndex;
-}
-
-export type OptionalIndexedAccessIndex =
-  | {kind: 'StrLitIndex'; name: string}
-  | {kind: 'TypeIndex'; type: FlowType};
-
-export interface OptionalIndexedAccessResultTypeDestructor {
-  kind: 'OptionalIndexedAccessResultType';
-}
-
-export interface ExactTypeDestructor {
-  kind: 'ExactType';
-}
-
-export interface ReadOnlyTypeDestructor {
-  kind: 'ReadOnlyType';
-}
-
-export interface PartialTypeDestructor {
-  kind: 'PartialType';
-}
-
-export interface RequiredTypeDestructor {
-  kind: 'RequiredType';
-}
-
-export interface SpreadTypeDestructor {
-  kind: 'SpreadType';
-  target: SpreadTarget;
-  operands: Array<SpreadOperand>;
-  operand_slice: Slice | null;
-}
-
-export type SpreadTarget =
-  | {kind: 'Value'; make_seal: 'Sealed' | 'Frozen' | 'As_Const'}
-  | {kind: 'Annot'; make_exact: boolean};
-
-export type SpreadOperand = {kind: 'Type'; type: FlowType} | Slice;
-
-export interface Slice {
-  kind: 'Slice';
-  prop_map: PropertyMap;
-  generics: Array<string>;
-  dict: DictType | null;
-  reachable_targs: Array<{
-    type: FlowType;
-    polarity: Polarity;
-  }>;
-}
-
-export interface SpreadTupleTypeDestructor {
-  kind: 'SpreadTupleType';
-  inexact: boolean;
-  resolved_rev: string;
-  unresolved: string;
-}
-
-export interface RestTypeDestructor {
-  kind: 'RestType';
-  merge_mode: RestMergeMode;
-  type: FlowType;
-}
-
-export type RestMergeMode =
-  | {kind: 'SpreadReversal'}
-  | {kind: 'ReactConfigMerge'; polarity: Polarity}
-  | {kind: 'Omit'};
-
-export interface ValuesTypeDestructor {
-  kind: 'ValuesType';
-}
-
-export interface ConditionalTypeDestructor {
-  kind: 'ConditionalType';
-  distributive_tparam_name: string | null;
-  infer_tparams: string;
-  extends_t: FlowType;
-  true_t: FlowType;
-  false_t: FlowType;
-}
-
-export interface TypeMapDestructor {
-  kind: 'ObjectKeyMirror';
-}
-
-export interface ReactElementPropsTypeDestructor {
-  kind: 'ReactElementPropsType';
-}
-
-export interface ReactElementConfigTypeDestructor {
-  kind: 'ReactElementConfigType';
-}
-
-export interface ReactCheckComponentConfigDestructor {
-  kind: 'ReactCheckComponentConfig';
-  props: {
-    [key: string]: Property;
-  };
-}
-
-export interface ReactDRODestructor {
-  kind: 'ReactDRO';
-  dro_type:
-    | 'HookReturn'
-    | 'HookArg'
-    | 'Props'
-    | 'ImmutableAnnot'
-    | 'DebugAnnot';
-}
-
-export interface MakeHooklikeDestructor {
-  kind: 'MakeHooklike';
-}
-
-export interface MappedTypeDestructor {
-  kind: 'MappedType';
-  homomorphic: Homomorphic;
-  distributive_tparam_name: string | null;
-  property_type: FlowType;
-  mapped_type_flags: {
-    variance: Polarity;
-    optional: 'MakeOptional' | 'RemoveOptional' | 'KeepOptionality';
-  };
-}
-
-export type Homomorphic =
-  | {kind: 'Homomorphic'}
-  | {kind: 'Unspecialized'}
-  | {kind: 'SemiHomomorphic'; type: FlowType};
-
-export interface EnumTypeDestructor {
-  kind: 'EnumType';
-}
-
-// Union of all possible Flow types
-export type FlowType =
-  | OpenType
-  | DefType
-  | EvalType
-  | GenericType
-  | ThisInstanceType
-  | ThisTypeAppType
-  | TypeAppType
-  | FunProtoType
-  | ObjProtoType
-  | NullProtoType
-  | FunProtoBindType
-  | IntersectionType
-  | UnionType
-  | MaybeType
-  | OptionalType
-  | KeysType
-  | AnnotType
-  | OpaqueType
-  | NamespaceType
-  | AnyType
-  | StrUtilType;
--- a/compiler/packages/babel-plugin-react-compiler/src/Flood/TypeErrors.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Flood/TypeErrors.ts
@@ -1,131 +0,0 @@
-import {CompilerError, SourceLocation} from '..';
-import {
-  ConcreteType,
-  printConcrete,
-  printType,
-  StructuralValue,
-  Type,
-  VariableId,
-} from './Types';
-
-export function unsupportedLanguageFeature(
-  desc: string,
-  loc: SourceLocation,
-): never {
-  CompilerError.throwInvalidJS({
-    reason: `Typedchecker does not currently support language feature: ${desc}`,
-    loc,
-  });
-}
-
-export type UnificationError =
-  | {
-      kind: 'TypeUnification';
-      left: ConcreteType<Type>;
-      right: ConcreteType<Type>;
-    }
-  | {
-      kind: 'StructuralUnification';
-      left: StructuralValue;
-      right: ConcreteType<Type>;
-    };
-
-function printUnificationError(err: UnificationError): string {
-  if (err.kind === 'TypeUnification') {
-    return `${printConcrete(err.left, printType)} is incompatible with ${printConcrete(err.right, printType)}`;
-  } else {
-    return `structural ${err.left.kind} is incompatible with ${printConcrete(err.right, printType)}`;
-  }
-}
-
-export function raiseUnificationErrors(
-  errs: null | Array<UnificationError>,
-  loc: SourceLocation,
-): void {
-  if (errs != null) {
-    if (errs.length === 0) {
-      CompilerError.invariant(false, {
-        reason: 'Should not have array of zero errors',
-        loc,
-      });
-    } else if (errs.length === 1) {
-      CompilerError.throwInvalidJS({
-        reason: `Unable to unify types because ${printUnificationError(errs[0])}`,
-        loc,
-      });
-    } else {
-      const messages = errs
-        .map(err => `\t* ${printUnificationError(err)}`)
-        .join('\n');
-      CompilerError.throwInvalidJS({
-        reason: `Unable to unify types because:\n${messages}`,
-        loc,
-      });
-    }
-  }
-}
-
-export function unresolvableTypeVariable(
-  id: VariableId,
-  loc: SourceLocation,
-): never {
-  CompilerError.throwInvalidJS({
-    reason: `Unable to resolve free variable ${id} to a concrete type`,
-    loc,
-  });
-}
-
-export function cannotAddVoid(explicit: boolean, loc: SourceLocation): never {
-  if (explicit) {
-    CompilerError.throwInvalidJS({
-      reason: `Undefined is not a valid operand of \`+\``,
-      loc,
-    });
-  } else {
-    CompilerError.throwInvalidJS({
-      reason: `Value may be undefined, which is not a valid operand of \`+\``,
-      loc,
-    });
-  }
-}
-
-export function unsupportedTypeAnnotation(
-  desc: string,
-  loc: SourceLocation,
-): never {
-  CompilerError.throwInvalidJS({
-    reason: `Typedchecker does not currently support type annotation: ${desc}`,
-    loc,
-  });
-}
-
-export function checkTypeArgumentArity(
-  desc: string,
-  expected: number,
-  actual: number,
-  loc: SourceLocation,
-): void {
-  if (expected !== actual) {
-    CompilerError.throwInvalidJS({
-      reason: `Expected ${desc} to have ${expected} type parameters, got ${actual}`,
-      loc,
-    });
-  }
-}
-
-export function notAFunction(desc: string, loc: SourceLocation): void {
-  CompilerError.throwInvalidJS({
-    reason: `Cannot call ${desc} because it is not a function`,
-    loc,
-  });
-}
-
-export function notAPolymorphicFunction(
-  desc: string,
-  loc: SourceLocation,
-): void {
-  CompilerError.throwInvalidJS({
-    reason: `Cannot call ${desc} with type arguments because it is not a polymorphic function`,
-    loc,
-  });
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Flood/TypeUtils.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Flood/TypeUtils.ts
@@ -1,312 +0,0 @@
-import {GeneratedSource} from '../HIR';
-import {assertExhaustive} from '../Utils/utils';
-import {unsupportedLanguageFeature} from './TypeErrors';
-import {
-  ConcreteType,
-  ResolvedType,
-  TypeParameter,
-  TypeParameterId,
-  DEBUG,
-  printConcrete,
-  printType,
-} from './Types';
-
-export function substitute(
-  type: ConcreteType<ResolvedType>,
-  typeParameters: Array<TypeParameter<ResolvedType>>,
-  typeArguments: Array<ResolvedType>,
-): ResolvedType {
-  const substMap = new Map<TypeParameterId, ResolvedType>();
-  for (let i = 0; i < typeParameters.length; i++) {
-    // TODO: Length checks to make sure type params match up with args
-    const typeParameter = typeParameters[i];
-    const typeArgument = typeArguments[i];
-    substMap.set(typeParameter.id, typeArgument);
-  }
-  const substitutionFunction = (t: ResolvedType): ResolvedType => {
-    // TODO: We really want a stateful mapper or visitor here so that we can model nested polymorphic types
-    if (t.type.kind === 'Generic' && substMap.has(t.type.id)) {
-      const substitutedType = substMap.get(t.type.id)!;
-      return substitutedType;
-    }
-
-    return {
-      kind: 'Concrete',
-      type: mapType(substitutionFunction, t.type),
-      platform: t.platform,
-    };
-  };
-
-  const substituted = mapType(substitutionFunction, type);
-
-  if (DEBUG) {
-    let substs = '';
-    for (let i = 0; i < typeParameters.length; i++) {
-      const typeParameter = typeParameters[i];
-      const typeArgument = typeArguments[i];
-      substs += `[${typeParameter.name}${typeParameter.id} := ${printType(typeArgument)}]`;
-    }
-    console.log(
-      `${printConcrete(type, printType)}${substs} = ${printConcrete(substituted, printType)}`,
-    );
-  }
-
-  return {kind: 'Concrete', type: substituted, platform: /* TODO */ 'shared'};
-}
-
-export function mapType<T, U>(
-  f: (t: T) => U,
-  type: ConcreteType<T>,
-): ConcreteType<U> {
-  switch (type.kind) {
-    case 'Mixed':
-    case 'Number':
-    case 'String':
-    case 'Boolean':
-    case 'Void':
-      return type;
-
-    case 'Nullable':
-      return {
-        kind: 'Nullable',
-        type: f(type.type),
-      };
-
-    case 'Array':
-      return {
-        kind: 'Array',
-        element: f(type.element),
-      };
-
-    case 'Set':
-      return {
-        kind: 'Set',
-        element: f(type.element),
-      };
-
-    case 'Map':
-      return {
-        kind: 'Map',
-        key: f(type.key),
-        value: f(type.value),
-      };
-
-    case 'Function':
-      return {
-        kind: 'Function',
-        typeParameters:
-          type.typeParameters?.map(param => ({
-            id: param.id,
-            name: param.name,
-            bound: f(param.bound),
-          })) ?? null,
-        params: type.params.map(f),
-        returnType: f(type.returnType),
-      };
-
-    case 'Component': {
-      return {
-        kind: 'Component',
-        children: type.children != null ? f(type.children) : null,
-        props: new Map([...type.props.entries()].map(([k, v]) => [k, f(v)])),
-      };
-    }
-
-    case 'Generic':
-      return {
-        kind: 'Generic',
-        id: type.id,
-        bound: f(type.bound),
-      };
-
-    case 'Object':
-      return type;
-
-    case 'Tuple':
-      return {
-        kind: 'Tuple',
-        id: type.id,
-        members: type.members.map(f),
-      };
-
-    case 'Structural':
-      return type;
-
-    case 'Enum':
-    case 'Union':
-    case 'Instance':
-      unsupportedLanguageFeature(type.kind, GeneratedSource);
-
-    default:
-      assertExhaustive(type, 'Unknown type kind');
-  }
-}
-
-export function diff<R, T>(
-  a: ConcreteType<T>,
-  b: ConcreteType<T>,
-  onChild: (a: T, b: T) => R,
-  onChildMismatch: (child: R, cur: R) => R,
-  onMismatch: (a: ConcreteType<T>, b: ConcreteType<T>, cur: R) => R,
-  init: R,
-): R {
-  let errors = init;
-
-  // Check if kinds match
-  if (a.kind !== b.kind) {
-    errors = onMismatch(a, b, errors);
-    return errors;
-  }
-
-  // Based on kind, check other properties
-  switch (a.kind) {
-    case 'Mixed':
-    case 'Number':
-    case 'String':
-    case 'Boolean':
-    case 'Void':
-      // Simple types, no further checks needed
-      break;
-
-    case 'Nullable':
-      // Check the nested type
-      errors = onChildMismatch(onChild(a.type, (b as typeof a).type), errors);
-      break;
-
-    case 'Array':
-    case 'Set':
-      // Check the element type
-      errors = onChildMismatch(
-        onChild(a.element, (b as typeof a).element),
-        errors,
-      );
-      break;
-
-    case 'Map':
-      // Check both key and value types
-      errors = onChildMismatch(onChild(a.key, (b as typeof a).key), errors);
-      errors = onChildMismatch(onChild(a.value, (b as typeof a).value), errors);
-      break;
-
-    case 'Function': {
-      const bFunc = b as typeof a;
-
-      // Check type parameters
-      if ((a.typeParameters == null) !== (bFunc.typeParameters == null)) {
-        errors = onMismatch(a, b, errors);
-      }
-
-      if (a.typeParameters != null && bFunc.typeParameters != null) {
-        if (a.typeParameters.length !== bFunc.typeParameters.length) {
-          errors = onMismatch(a, b, errors);
-        }
-
-        // Type parameters are just numbers, so we can compare them directly
-        for (let i = 0; i < a.typeParameters.length; i++) {
-          if (a.typeParameters[i] !== bFunc.typeParameters[i]) {
-            errors = onMismatch(a, b, errors);
-          }
-        }
-      }
-
-      // Check parameters
-      if (a.params.length !== bFunc.params.length) {
-        errors = onMismatch(a, b, errors);
-      }
-
-      for (let i = 0; i < a.params.length; i++) {
-        errors = onChildMismatch(onChild(a.params[i], bFunc.params[i]), errors);
-      }
-
-      // Check return type
-      errors = onChildMismatch(onChild(a.returnType, bFunc.returnType), errors);
-      break;
-    }
-
-    case 'Component': {
-      const bComp = b as typeof a;
-
-      // Check children
-      if (a.children !== bComp.children) {
-        errors = onMismatch(a, b, errors);
-      }
-
-      // Check props
-      if (a.props.size !== bComp.props.size) {
-        errors = onMismatch(a, b, errors);
-      }
-
-      for (const [k, v] of a.props) {
-        const bProp = bComp.props.get(k);
-        if (bProp == null) {
-          errors = onMismatch(a, b, errors);
-        } else {
-          errors = onChildMismatch(onChild(v, bProp), errors);
-        }
-      }
-
-      break;
-    }
-
-    case 'Generic': {
-      // Check that the type parameter IDs match
-      if (a.id !== (b as typeof a).id) {
-        errors = onMismatch(a, b, errors);
-      }
-      break;
-    }
-    case 'Structural': {
-      const bStruct = b as typeof a;
-
-      // Check that the structural IDs match
-      if (a.id !== bStruct.id) {
-        errors = onMismatch(a, b, errors);
-      }
-      break;
-    }
-    case 'Object': {
-      const bNom = b as typeof a;
-
-      // Check that the nominal IDs match
-      if (a.id !== bNom.id) {
-        errors = onMismatch(a, b, errors);
-      }
-      break;
-    }
-
-    case 'Tuple': {
-      const bTuple = b as typeof a;
-
-      // Check that the tuple IDs match
-      if (a.id !== bTuple.id) {
-        errors = onMismatch(a, b, errors);
-      }
-      for (let i = 0; i < a.members.length; i++) {
-        errors = onChildMismatch(
-          onChild(a.members[i], bTuple.members[i]),
-          errors,
-        );
-      }
-
-      break;
-    }
-
-    case 'Enum':
-    case 'Instance':
-    case 'Union': {
-      unsupportedLanguageFeature(a.kind, GeneratedSource);
-    }
-
-    default:
-      assertExhaustive(a, 'Unknown type kind');
-  }
-
-  return errors;
-}
-
-export function filterOptional(t: ResolvedType): ResolvedType {
-  if (t.kind === 'Concrete' && t.type.kind === 'Nullable') {
-    return t.type.type;
-  }
-  return t;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Flood/Types.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Flood/Types.ts
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/AssertValidBlockNesting.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/AssertValidBlockNesting.ts
@@ -1,10 +1,3 @@
-/**
- * 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 {
  BlockId,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/AssertValidMutableRanges.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/AssertValidMutableRanges.ts
@@ -5,14 +5,13 @@
 * LICENSE file in the root directory of this source tree.
 */

-import {HIRFunction, MutableRange, Place} from './HIR';
+import invariant from 'invariant';
+import {HIRFunction, Identifier, MutableRange} from './HIR';
 import {
  eachInstructionLValue,
  eachInstructionOperand,
  eachTerminalOperand,
 } from './visitors';
-import {CompilerError} from '..';
-import {printPlace} from './PrintHIR';

 /*
 * Checks that all mutable ranges in the function are well-formed, with
@@ -21,43 +20,38 @@ import {printPlace} from './PrintHIR';
 export function assertValidMutableRanges(fn: HIRFunction): void {
  for (const [, block] of fn.body.blocks) {
    for (const phi of block.phis) {
-      visit(phi.place, `phi for block bb${block.id}`);
-      for (const [pred, operand] of phi.operands) {
-        visit(operand, `phi predecessor bb${pred} for block bb${block.id}`);
+      visitIdentifier(phi.place.identifier);
+      for (const [, operand] of phi.operands) {
+        visitIdentifier(operand.identifier);
      }
    }
    for (const instr of block.instructions) {
      for (const operand of eachInstructionLValue(instr)) {
-        visit(operand, `instruction [${instr.id}]`);
+        visitIdentifier(operand.identifier);
      }
      for (const operand of eachInstructionOperand(instr)) {
-        visit(operand, `instruction [${instr.id}]`);
+        visitIdentifier(operand.identifier);
      }
    }
    for (const operand of eachTerminalOperand(block.terminal)) {
-      visit(operand, `terminal [${block.terminal.id}]`);
+      visitIdentifier(operand.identifier);
    }
  }
 }

-function visit(place: Place, description: string): void {
-  validateMutableRange(place, place.identifier.mutableRange, description);
-  if (place.identifier.scope !== null) {
-    validateMutableRange(place, place.identifier.scope.range, description);
+function visitIdentifier(identifier: Identifier): void {
+  validateMutableRange(identifier.mutableRange);
+  if (identifier.scope !== null) {
+    validateMutableRange(identifier.scope.range);
  }
 }

-function validateMutableRange(
-  place: Place,
-  range: MutableRange,
-  description: string,
-): void {
-  CompilerError.invariant(
-    (range.start === 0 && range.end === 0) || range.end > range.start,
-    {
-      reason: `Invalid mutable range: [${range.start}:${range.end}]`,
-      description: `${printPlace(place)} in ${description}`,
-      loc: place.loc,
-    },
+function validateMutableRange(mutableRange: MutableRange): void {
+  invariant(
+    (mutableRange.start === 0 && mutableRange.end === 0) ||
+      mutableRange.end > mutableRange.start,
+    'Identifier scope mutableRange was invalid: [%s:%s]',
+    mutableRange.start,
+    mutableRange.end,
  );
 }
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildReactiveScopeTerminalsHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildReactiveScopeTerminalsHIR.ts
@@ -1,10 +1,3 @@
-/**
- * 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 '../CompilerError';
 import {getScopes, recursivelyTraverseItems} from './AssertValidBlockNesting';
 import {Environment} from './Environment';
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/CollectHoistablePropertyLoads.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/CollectHoistablePropertyLoads.ts
@@ -1,10 +1,3 @@
-/**
- * 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 '../CompilerError';
 import {inRange} from '../ReactiveScopes/InferReactiveScopeVariables';
 import {printDependency} from '../ReactiveScopes/PrintReactiveFunction';
@@ -19,7 +12,6 @@ import {
  BasicBlock,
  BlockId,
  DependencyPathEntry,
-  FunctionExpression,
  GeneratedSource,
  getHookKind,
  HIRFunction,
@@ -31,7 +23,6 @@ import {
  PropertyLiteral,
  ReactiveScopeDependency,
  ScopeId,
-  TInstruction,
 } from './HIR';

 const DEBUG_PRINT = false;
@@ -129,33 +120,6 @@ export function collectHoistablePropertyLoads(
  });
 }

-export function collectHoistablePropertyLoadsInInnerFn(
-  fnInstr: TInstruction<FunctionExpression>,
-  temporaries: ReadonlyMap<IdentifierId, ReactiveScopeDependency>,
-  hoistableFromOptionals: ReadonlyMap<BlockId, ReactiveScopeDependency>,
-): ReadonlyMap<BlockId, BlockInfo> {
-  const fn = fnInstr.value.loweredFunc.func;
-  const initialContext: CollectHoistablePropertyLoadsContext = {
-    temporaries,
-    knownImmutableIdentifiers: new Set(),
-    hoistableFromOptionals,
-    registry: new PropertyPathRegistry(),
-    nestedFnImmutableContext: null,
-    assumedInvokedFns: fn.env.config.enableTreatFunctionDepsAsConditional
-      ? new Set()
-      : getAssumedInvokedFunctions(fn),
-  };
-  const nestedFnImmutableContext = new Set(
-    fn.context
-      .filter(place =>
-        isImmutableAtInstr(place.identifier, fnInstr.id, initialContext),
-      )
-      .map(place => place.identifier.id),
-  );
-  initialContext.nestedFnImmutableContext = nestedFnImmutableContext;
-  return collectHoistablePropertyLoadsImpl(fn, initialContext);
-}
-
 type CollectHoistablePropertyLoadsContext = {
  temporaries: ReadonlyMap<IdentifierId, ReactiveScopeDependency>;
  knownImmutableIdentifiers: ReadonlySet<IdentifierId>;
@@ -241,10 +205,7 @@ type PropertyPathNode =
 class PropertyPathRegistry {
  roots: Map<IdentifierId, RootNode> = new Map();

-  getOrCreateIdentifier(
-    identifier: Identifier,
-    reactive: boolean,
-  ): PropertyPathNode {
+  getOrCreateIdentifier(identifier: Identifier): PropertyPathNode {
    /**
     * Reads from a statically scoped variable are always safe in JS,
     * with the exception of TDZ (not addressed by this pass).
@@ -258,19 +219,12 @@ class PropertyPathRegistry {
        optionalProperties: new Map(),
        fullPath: {
          identifier,
-          reactive,
          path: [],
        },
        hasOptional: false,
        parent: null,
      };
      this.roots.set(identifier.id, rootNode);
-    } else {
-      CompilerError.invariant(reactive === rootNode.fullPath.reactive, {
-        reason:
-          '[HoistablePropertyLoads] Found inconsistencies in `reactive` flag when deduping identifier reads within the same scope',
-        loc: identifier.loc,
-      });
    }
    return rootNode;
  }
@@ -288,7 +242,6 @@ class PropertyPathRegistry {
        parent: parent,
        fullPath: {
          identifier: parent.fullPath.identifier,
-          reactive: parent.fullPath.reactive,
          path: parent.fullPath.path.concat(entry),
        },
        hasOptional: parent.hasOptional || entry.optional,
@@ -304,7 +257,7 @@ class PropertyPathRegistry {
     * so all subpaths of a PropertyLoad should already exist
     * (e.g. a.b is added before a.b.c),
     */
-    let currNode = this.getOrCreateIdentifier(n.identifier, n.reactive);
+    let currNode = this.getOrCreateIdentifier(n.identifier);
    if (n.path.length === 0) {
      return currNode;
    }
@@ -326,11 +279,10 @@ function getMaybeNonNullInInstruction(
  instr: InstructionValue,
  context: CollectHoistablePropertyLoadsContext,
 ): PropertyPathNode | null {
-  let path: ReactiveScopeDependency | null = null;
+  let path = null;
  if (instr.kind === 'PropertyLoad') {
    path = context.temporaries.get(instr.object.identifier.id) ?? {
      identifier: instr.object.identifier,
-      reactive: instr.object.reactive,
      path: [],
    };
  } else if (instr.kind === 'Destructure') {
@@ -393,7 +345,7 @@ function collectNonNullsInBlocks(
  ) {
    const identifier = fn.params[0].identifier;
    knownNonNullIdentifiers.add(
-      context.registry.getOrCreateIdentifier(identifier, true),
+      context.registry.getOrCreateIdentifier(identifier),
    );
  }
  const nodes = new Map<
@@ -628,11 +580,9 @@ function reduceMaybeOptionalChains(
    changed = false;

    for (const original of optionalChainNodes) {
-      let {identifier, path: origPath, reactive} = original.fullPath;
-      let currNode: PropertyPathNode = registry.getOrCreateIdentifier(
-        identifier,
-        reactive,
-      );
+      let {identifier, path: origPath} = original.fullPath;
+      let currNode: PropertyPathNode =
+        registry.getOrCreateIdentifier(identifier);
      for (let i = 0; i < origPath.length; i++) {
        const entry = origPath[i];
        // If the base is known to be non-null, replace with a non-optional load
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts
@@ -1,10 +1,3 @@
-/**
- * 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 {assertNonNull} from './CollectHoistablePropertyLoads';
 import {
@@ -290,7 +283,6 @@ function traverseOptionalBlock(
    );
    baseObject = {
      identifier: maybeTest.instructions[0].value.place.identifier,
-      reactive: maybeTest.instructions[0].value.place.reactive,
      path,
    };
    test = maybeTest.terminal;
@@ -392,7 +384,6 @@ function traverseOptionalBlock(
  );
  const load = {
    identifier: baseObject.identifier,
-    reactive: baseObject.reactive,
    path: [
      ...baseObject.path,
      {
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/DeriveMinimalDependenciesHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/DeriveMinimalDependenciesHIR.ts
@@ -25,9 +25,8 @@ export class ReactiveScopeDependencyTreeHIR {
   * `identifier.path`, or `identifier?.path` is in this map, it is safe to
   * evaluate (non-optional) PropertyLoads from.
   */
-  #hoistableObjects: Map<Identifier, HoistableNode & {reactive: boolean}> =
-    new Map();
-  #deps: Map<Identifier, DependencyNode & {reactive: boolean}> = new Map();
+  #hoistableObjects: Map<Identifier, HoistableNode> = new Map();
+  #deps: Map<Identifier, DependencyNode> = new Map();

  /**
   * @param hoistableObjects a set of paths from which we can safely evaluate
@@ -36,10 +35,9 @@ export class ReactiveScopeDependencyTreeHIR {
   * duplicates when traversing the CFG.
   */
  constructor(hoistableObjects: Iterable<ReactiveScopeDependency>) {
-    for (const {path, identifier, reactive} of hoistableObjects) {
+    for (const {path, identifier} of hoistableObjects) {
      let currNode = ReactiveScopeDependencyTreeHIR.#getOrCreateRoot(
        identifier,
-        reactive,
        this.#hoistableObjects,
        path.length > 0 && path[0].optional ? 'Optional' : 'NonNull',
      );
@@ -72,8 +70,7 @@ export class ReactiveScopeDependencyTreeHIR {

  static #getOrCreateRoot<T extends string>(
    identifier: Identifier,
-    reactive: boolean,
-    roots: Map<Identifier, TreeNode<T> & {reactive: boolean}>,
+    roots: Map<Identifier, TreeNode<T>>,
    defaultAccessType: T,
  ): TreeNode<T> {
    // roots can always be accessed unconditionally in JS
@@ -82,16 +79,9 @@ export class ReactiveScopeDependencyTreeHIR {
    if (rootNode === undefined) {
      rootNode = {
        properties: new Map(),
-        reactive,
        accessType: defaultAccessType,
      };
      roots.set(identifier, rootNode);
-    } else {
-      CompilerError.invariant(reactive === rootNode.reactive, {
-        reason: '[DeriveMinimalDependenciesHIR] Conflicting reactive root flag',
-        description: `Identifier ${printIdentifier(identifier)}`,
-        loc: GeneratedSource,
-      });
    }
    return rootNode;
  }
@@ -102,10 +92,9 @@ export class ReactiveScopeDependencyTreeHIR {
   * safe-to-evaluate subpath
   */
  addDependency(dep: ReactiveScopeDependency): void {
-    const {identifier, reactive, path} = dep;
+    const {identifier, path} = dep;
    let depCursor = ReactiveScopeDependencyTreeHIR.#getOrCreateRoot(
      identifier,
-      reactive,
      this.#deps,
      PropertyAccessType.UnconditionalAccess,
    );
@@ -183,13 +172,7 @@ export class ReactiveScopeDependencyTreeHIR {
  deriveMinimalDependencies(): Set<ReactiveScopeDependency> {
    const results = new Set<ReactiveScopeDependency>();
    for (const [rootId, rootNode] of this.#deps.entries()) {
-      collectMinimalDependenciesInSubtree(
-        rootNode,
-        rootNode.reactive,
-        rootId,
-        [],
-        results,
-      );
+      collectMinimalDependenciesInSubtree(rootNode, rootId, [], results);
    }

    return results;
@@ -311,24 +294,25 @@ type HoistableNode = TreeNode<'Optional' | 'NonNull'>;
 type DependencyNode = TreeNode<PropertyAccessType>;

 /**
+ * TODO: this is directly pasted from DeriveMinimalDependencies. Since we no
+ * longer have conditionally accessed nodes, we can simplify
+ *
 * Recursively calculates minimal dependencies in a subtree.
 * @param node DependencyNode representing a dependency subtree.
 * @returns a minimal list of dependencies in this subtree.
 */
 function collectMinimalDependenciesInSubtree(
  node: DependencyNode,
-  reactive: boolean,
  rootIdentifier: Identifier,
  path: Array<DependencyPathEntry>,
  results: Set<ReactiveScopeDependency>,
 ): void {
  if (isDependency(node.accessType)) {
-    results.add({identifier: rootIdentifier, reactive, path});
+    results.add({identifier: rootIdentifier, path});
  } else {
    for (const [childName, childNode] of node.properties) {
      collectMinimalDependenciesInSubtree(
        childNode,
-        reactive,
        rootIdentifier,
        [
          ...path,
--- 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,13 @@ import * as t from '@babel/types';
 import {ZodError, z} from 'zod';
 import {fromZodError} from 'zod-validation-error';
 import {CompilerError} from '../CompilerError';
-import {Logger, ProgramContext} from '../Entrypoint';
+import {
+  CompilationMode,
+  Logger,
+  PanicThresholdOptions,
+  parsePluginOptions,
+  PluginOptions,
+} from '../Entrypoint';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
  DEFAULT_GLOBALS,
@@ -47,9 +53,8 @@ import {
  ShapeRegistry,
  addHook,
 } from './ObjectShape';
-import {Scope as BabelScope, NodePath} from '@babel/traverse';
+import {Scope as BabelScope} from '@babel/traverse';
 import {TypeSchema} from './TypeSchema';
-import {FlowTypeEnv} from '../Flood/Types';

 export const ReactElementSymbolSchema = z.object({
  elementSymbol: z.union([
@@ -79,8 +84,6 @@ export const InstrumentationSchema = z
  );

 export type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
-export const USE_FIRE_FUNCTION_NAME = 'useFire';
-export const EMIT_FREEZE_GLOBAL_GATING = '__DEV__';

 export const MacroMethodSchema = z.union([
  z.object({type: z.literal('wildcard')}),
@@ -151,7 +154,7 @@ export type Hook = z.infer<typeof HookSchema>;
 *   missing some recursive Object / Function shapeIds
 */

-export const EnvironmentConfigSchema = z.object({
+const EnvironmentConfigSchema = z.object({
  customHooks: z.map(z.string(), HookSchema).default(new Map()),

  /**
@@ -244,12 +247,6 @@ export const EnvironmentConfigSchema = z.object({
   */
  enableUseTypeAnnotations: z.boolean().default(false),

-  /**
-   * Allows specifying a function that can populate HIR with type information from
-   * Flow
-   */
-  flowTypeProvider: z.nullable(z.function().args(z.string())).default(null),
-
  /**
   * Enables inference of optional dependency chains. Without this flag
   * a property chain such as `props?.items?.foo` will infer as a dep on
@@ -267,19 +264,21 @@ export const EnvironmentConfigSchema = z.object({
   *   {
   *     module: 'react',
   *     imported: 'useEffect',
-   *     autodepsIndex: 1,
+   *     numRequiredArgs: 1,
   *   },{
   *     module: 'MyExperimentalEffectHooks',
   *     imported: 'useExperimentalEffect',
-   *     autodepsIndex: 2,
+   *     numRequiredArgs: 2,
   *   },
   * ]
   * would insert dependencies for calls of `useEffect` imported from `react` and calls of
   * useExperimentalEffect` from `MyExperimentalEffectHooks`.
   *
-   * `autodepsIndex` tells the compiler which index we expect the AUTODEPS to appear in.
-   *  With the configuration above, we'd insert dependencies for `useEffect` if it has two
-   *  arguments, and the second is AUTODEPS.
+   * `numRequiredArgs` tells the compiler the amount of arguments required to append a dependency
+   *  array to the end of the call. With the configuration above, we'd insert dependencies for
+   *  `useEffect` if it is only given a single argument and it would be appended to the argument list.
+   *
+   * numRequiredArgs must always be greater than 0, otherwise there is no function to analyze for dependencies
   *
   * Still experimental.
   */
@@ -288,7 +287,7 @@ export const EnvironmentConfigSchema = z.object({
      z.array(
        z.object({
          function: ExternalFunctionSchema,
-          autodepsIndex: z.number().min(1, 'autodepsIndex must be > 0'),
+          numRequiredArgs: z.number().min(1, 'numRequiredArgs must be > 0'),
        }),
      ),
    )
@@ -320,16 +319,10 @@ export const EnvironmentConfigSchema = z.object({
  validateNoSetStateInRender: z.boolean().default(true),

  /**
-   * Validates that setState is not called synchronously within an effect (useEffect and friends).
+   * Validates that setState is not called directly within a passive effect (useEffect).
   * Scheduling a setState (with an event listener, subscription, etc) is valid.
   */
-  validateNoSetStateInEffects: z.boolean().default(false),
-
-  /**
-   * Validates that effects are not used to calculate derived data which could instead be computed
-   * during render.
-   */
-  validateNoDerivedComputationsInEffects: z.boolean().default(false),
+  validateNoSetStateInPassiveEffects: z.boolean().default(false),

  /**
   * Validates against creating JSX within a try block and recommends using an error boundary
@@ -337,11 +330,6 @@ export const EnvironmentConfigSchema = z.object({
   */
  validateNoJSXInTryStatements: z.boolean().default(false),

-  /**
-   * Validates against dynamically creating components during render.
-   */
-  validateStaticComponents: z.boolean().default(false),
-
  /**
   * Validates that the dependencies of all effect hooks are memoized. This helps ensure
   * that Forget does not introduce infinite renders caused by a dependency changing,
@@ -370,11 +358,6 @@ export const EnvironmentConfigSchema = z.object({
   */
  validateNoImpureFunctionsInRender: z.boolean().default(false),

-  /**
-   * Validate against passing mutable functions to hooks
-   */
-  validateNoFreezingKnownMutableFunctions: z.boolean().default(false),
-
  /*
   * When enabled, the compiler assumes that hooks follow the Rules of React:
   * - Hooks may memoize computation based on any of their parameters, thus
@@ -616,7 +599,7 @@ export const EnvironmentConfigSchema = z.object({
   *
   * Here the variables `ref` and `myRef` will be typed as Refs.
   */
-  enableTreatRefLikeIdentifiersAsRefs: z.boolean().default(true),
+  enableTreatRefLikeIdentifiersAsRefs: z.boolean().default(false),

  /*
   * If specified a value, the compiler lowers any calls to `useContext` to use
@@ -639,28 +622,189 @@ export const EnvironmentConfigSchema = z.object({
   * ```
   */
  lowerContextAccess: ExternalFunctionSchema.nullable().default(null),
-
-  /**
-   * If enabled, will validate useMemos that don't return any values:
-   *
-   * Valid:
-   *   useMemo(() => foo, [foo]);
-   *   useMemo(() => { return foo }, [foo]);
-   * Invalid:
-   *   useMemo(() => { ... }, [...]);
-   */
-  validateNoVoidUseMemo: z.boolean().default(false),
-
-  /**
-   * Validates that Components/Hooks are always defined at module level. This prevents scope
-   * reference errors that occur when the compiler attempts to optimize the nested component/hook
-   * while its parent function remains uncompiled.
-   */
-  validateNoDynamicallyCreatedComponentsOrHooks: z.boolean().default(false),
 });

 export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;

+/**
+ * For test fixtures and playground only.
+ *
+ * Pragmas are straightforward to parse for boolean options (`:true` and
+ * `:false`). These are 'enabled' config values for non-boolean configs (i.e.
+ * what is used when parsing `:true`).
+ */
+const testComplexConfigDefaults: PartialEnvironmentConfig = {
+  validateNoCapitalizedCalls: [],
+  enableChangeDetectionForDebugging: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$structuralCheck',
+  },
+  enableEmitFreeze: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'makeReadOnly',
+  },
+  enableEmitInstrumentForget: {
+    fn: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'useRenderCounter',
+    },
+    gating: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'shouldInstrument',
+    },
+    globalGating: 'DEV',
+  },
+  enableEmitHookGuards: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$dispatcherGuard',
+  },
+  inlineJsxTransform: {
+    elementSymbol: 'react.transitional.element',
+    globalDevVar: 'DEV',
+  },
+  lowerContextAccess: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'useContext_withSelector',
+  },
+  inferEffectDependencies: [
+    {
+      function: {
+        source: 'react',
+        importSpecifierName: 'useEffect',
+      },
+      numRequiredArgs: 1,
+    },
+    {
+      function: {
+        source: 'shared-runtime',
+        importSpecifierName: 'useSpecialEffect',
+      },
+      numRequiredArgs: 2,
+    },
+    {
+      function: {
+        source: 'useEffectWrapper',
+        importSpecifierName: 'default',
+      },
+      numRequiredArgs: 1,
+    },
+  ],
+};
+
+/**
+ * For snap test fixtures and playground only.
+ */
+function parseConfigPragmaEnvironmentForTest(
+  pragma: string,
+): EnvironmentConfig {
+  const maybeConfig: any = {};
+  // Get the defaults to programmatically check for boolean properties
+  const defaultConfig = EnvironmentConfigSchema.parse({});
+
+  for (const token of pragma.split(' ')) {
+    if (!token.startsWith('@')) {
+      continue;
+    }
+    const keyVal = token.slice(1);
+    let [key, val = undefined] = keyVal.split(':');
+    const isSet = val === undefined || val === 'true';
+
+    if (isSet && key in testComplexConfigDefaults) {
+      maybeConfig[key] =
+        testComplexConfigDefaults[key as keyof PartialEnvironmentConfig];
+      continue;
+    }
+
+    if (key === 'customMacros' && val) {
+      const valSplit = val.split('.');
+      if (valSplit.length > 0) {
+        const props = [];
+        for (const elt of valSplit.slice(1)) {
+          if (elt === '*') {
+            props.push({type: 'wildcard'});
+          } else if (elt.length > 0) {
+            props.push({type: 'name', name: elt});
+          }
+        }
+        maybeConfig[key] = [[valSplit[0], props]];
+      }
+      continue;
+    }
+
+    if (
+      key !== 'enableResetCacheOnSourceFileChanges' &&
+      typeof defaultConfig[key as keyof EnvironmentConfig] !== 'boolean'
+    ) {
+      // skip parsing non-boolean properties
+      continue;
+    }
+    if (val === undefined || val === 'true') {
+      maybeConfig[key] = true;
+    } else {
+      maybeConfig[key] = false;
+    }
+  }
+  const config = EnvironmentConfigSchema.safeParse(maybeConfig);
+  if (config.success) {
+    /**
+     * Unless explicitly enabled, do not insert HMR handling code
+     * in test fixtures or playground to reduce visual noise.
+     */
+    if (config.data.enableResetCacheOnSourceFileChanges == null) {
+      config.data.enableResetCacheOnSourceFileChanges = false;
+    }
+    return config.data;
+  }
+  CompilerError.invariant(false, {
+    reason: 'Internal error, could not parse config from pragma string',
+    description: `${fromZodError(config.error)}`,
+    loc: null,
+    suggestions: null,
+  });
+}
+export function parseConfigPragmaForTests(
+  pragma: string,
+  defaults: {
+    compilationMode: CompilationMode;
+  },
+): PluginOptions {
+  const environment = parseConfigPragmaEnvironmentForTest(pragma);
+  let compilationMode: CompilationMode = defaults.compilationMode;
+  let panicThreshold: PanicThresholdOptions = 'all_errors';
+  for (const token of pragma.split(' ')) {
+    if (!token.startsWith('@')) {
+      continue;
+    }
+    switch (token) {
+      case '@compilationMode(annotation)': {
+        compilationMode = 'annotation';
+        break;
+      }
+      case '@compilationMode(infer)': {
+        compilationMode = 'infer';
+        break;
+      }
+      case '@compilationMode(all)': {
+        compilationMode = 'all';
+        break;
+      }
+      case '@compilationMode(syntax)': {
+        compilationMode = 'syntax';
+        break;
+      }
+      case '@panicThreshold(none)': {
+        panicThreshold = 'none';
+        break;
+      }
+    }
+  }
+  return parsePluginOptions({
+    environment,
+    compilationMode,
+    panicThreshold,
+  });
+}
+
 export type PartialEnvironmentConfig = Partial<EnvironmentConfig>;

 export type ReactFunctionType = 'Component' | 'Hook' | 'Other';
@@ -697,16 +841,12 @@ export class Environment {
  config: EnvironmentConfig;
  fnType: ReactFunctionType;
  compilerMode: CompilerMode;
-  programContext: ProgramContext;
+  useMemoCacheIdentifier: string;
+  hasLoweredContextAccess: boolean;
  hasFireRewrite: boolean;
-  hasInferredEffect: boolean;
-  inferredEffectLocations: Set<SourceLocation> = new Set();

  #contextIdentifiers: Set<t.Identifier>;
  #hoistedIdentifiers: Set<t.Identifier>;
-  parentFunction: NodePath<t.Function>;
-
-  #flowTypeEnvironment: FlowTypeEnv | null;

  constructor(
    scope: BabelScope,
@@ -714,11 +854,10 @@ export class Environment {
    compilerMode: CompilerMode,
    config: EnvironmentConfig,
    contextIdentifiers: Set<t.Identifier>,
-    parentFunction: NodePath<t.Function>, // the outermost function being compiled
    logger: Logger | null,
    filename: string | null,
    code: string | null,
-    programContext: ProgramContext,
+    useMemoCacheIdentifier: string,
  ) {
    this.#scope = scope;
    this.fnType = fnType;
@@ -727,11 +866,11 @@ export class Environment {
    this.filename = filename;
    this.code = code;
    this.logger = logger;
-    this.programContext = programContext;
+    this.useMemoCacheIdentifier = useMemoCacheIdentifier;
    this.#shapes = new Map(DEFAULT_SHAPES);
    this.#globals = new Map(DEFAULT_GLOBALS);
+    this.hasLoweredContextAccess = false;
    this.hasFireRewrite = false;
-    this.hasInferredEffect = false;

    if (
      config.disableMemoizationForDebugging &&
@@ -773,29 +912,8 @@ export class Environment {
      this.#moduleTypes.set(REANIMATED_MODULE_NAME, reanimatedModuleType);
    }

-    this.parentFunction = parentFunction;
    this.#contextIdentifiers = contextIdentifiers;
    this.#hoistedIdentifiers = new Set();
-
-    if (config.flowTypeProvider != null) {
-      this.#flowTypeEnvironment = new FlowTypeEnv();
-      CompilerError.invariant(code != null, {
-        reason:
-          'Expected Environment to be initialized with source code when a Flow type provider is specified',
-        loc: null,
-      });
-      this.#flowTypeEnvironment.init(this, code);
-    } else {
-      this.#flowTypeEnvironment = null;
-    }
-  }
-
-  get typeContext(): FlowTypeEnv {
-    CompilerError.invariant(this.#flowTypeEnvironment != null, {
-      reason: 'Flow type environment not initialized',
-      loc: null,
-    });
-    return this.#flowTypeEnvironment;
  }

  get isInferredMemoEnabled(): boolean {
@@ -814,23 +932,6 @@ export class Environment {
    return makeScopeId(this.#nextScope++);
  }

-  get scope(): BabelScope {
-    return this.#scope;
-  }
-
-  logErrors(errors: Result<void, CompilerError>): void {
-    if (errors.isOk() || this.logger == null) {
-      return;
-    }
-    for (const error of errors.unwrapErr().details) {
-      this.logger.logEvent(this.filename, {
-        kind: 'CompileError',
-        detail: error,
-        fnLoc: null,
-      });
-    }
-  }
-
  isContextIdentifier(node: t.Identifier): boolean {
    return this.#contextIdentifiers.has(node);
  }
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts
@@ -9,16 +9,10 @@ import {Effect, ValueKind, ValueReason} from './HIR';
 import {
  BUILTIN_SHAPES,
  BuiltInArrayId,
-  BuiltInAutodepsId,
-  BuiltInFireFunctionId,
  BuiltInFireId,
-  BuiltInMapId,
  BuiltInMixedReadonlyId,
-  BuiltInObjectId,
-  BuiltInSetId,
  BuiltInUseActionStateId,
  BuiltInUseContextHookId,
-  BuiltInUseEffectEventId,
  BuiltInUseEffectHookId,
  BuiltInUseInsertionEffectHookId,
  BuiltInUseLayoutEffectHookId,
@@ -27,10 +21,6 @@ import {
  BuiltInUseRefId,
  BuiltInUseStateId,
  BuiltInUseTransitionId,
-  BuiltInWeakMapId,
-  BuiltInWeakSetId,
-  BuiltinEffectEventId,
-  ReanimatedSharedValueId,
  ShapeRegistry,
  addFunction,
  addHook,
@@ -55,23 +45,29 @@ export const DEFAULT_SHAPES: ShapeRegistry = new Map(BUILTIN_SHAPES);

 // Hack until we add ObjectShapes for all globals
 const UNTYPED_GLOBALS: Set<string> = new Set([
+  'String',
  'Object',
  'Function',
+  'Number',
  'RegExp',
  'Date',
  'Error',
+  'Function',
  'TypeError',
  'RangeError',
  'ReferenceError',
  'SyntaxError',
  'URIError',
  'EvalError',
+  'Boolean',
  'DataView',
  'Float32Array',
  'Float64Array',
  'Int8Array',
  'Int16Array',
  'Int32Array',
+  'Map',
+  'Set',
  'WeakMap',
  'Uint8Array',
  'Uint8ClampedArray',
@@ -79,8 +75,16 @@ const UNTYPED_GLOBALS: Set<string> = new Set([
  'Uint32Array',
  'ArrayBuffer',
  'JSON',
+  'parseFloat',
+  'parseInt',
  'console',
+  'isNaN',
  'eval',
+  'isFinite',
+  'encodeURI',
+  'decodeURI',
+  'encodeURIComponent',
+  'decodeURIComponent',
 ]);

 const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
@@ -97,116 +101,6 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
          returnValueKind: ValueKind.Mutable,
        }),
      ],
-      [
-        /**
-         * Object.fromEntries(iterable)
-         * iterable: An iterable, such as an Array or Map, containing a list of
-         *           objects. Each object should have two properties.
-         * Returns a new object whose properties are given by the entries of the
-         * iterable.
-         */
-        'fromEntries',
-        addFunction(DEFAULT_SHAPES, [], {
-          positionalParams: [Effect.ConditionallyMutate],
-          restParam: null,
-          returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-          calleeEffect: Effect.Read,
-          returnValueKind: ValueKind.Mutable,
-        }),
-      ],
-      [
-        'entries',
-        addFunction(DEFAULT_SHAPES, [], {
-          positionalParams: [Effect.Capture],
-          restParam: null,
-          returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-          calleeEffect: Effect.Read,
-          returnValueKind: ValueKind.Mutable,
-          aliasing: {
-            receiver: '@receiver',
-            params: ['@object'],
-            rest: null,
-            returns: '@returns',
-            temporaries: [],
-            effects: [
-              {
-                kind: 'Create',
-                into: '@returns',
-                reason: ValueReason.KnownReturnSignature,
-                value: ValueKind.Mutable,
-              },
-              // Object values are captured into the return
-              {
-                kind: 'Capture',
-                from: '@object',
-                into: '@returns',
-              },
-            ],
-          },
-        }),
-      ],
-      [
-        'keys',
-        addFunction(DEFAULT_SHAPES, [], {
-          positionalParams: [Effect.Read],
-          restParam: null,
-          returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-          calleeEffect: Effect.Read,
-          returnValueKind: ValueKind.Mutable,
-          aliasing: {
-            receiver: '@receiver',
-            params: ['@object'],
-            rest: null,
-            returns: '@returns',
-            temporaries: [],
-            effects: [
-              {
-                kind: 'Create',
-                into: '@returns',
-                reason: ValueReason.KnownReturnSignature,
-                value: ValueKind.Mutable,
-              },
-              // Only keys are captured, and keys are immutable
-              {
-                kind: 'ImmutableCapture',
-                from: '@object',
-                into: '@returns',
-              },
-            ],
-          },
-        }),
-      ],
-      [
-        'values',
-        addFunction(DEFAULT_SHAPES, [], {
-          positionalParams: [Effect.Capture],
-          restParam: null,
-          returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-          calleeEffect: Effect.Read,
-          returnValueKind: ValueKind.Mutable,
-          aliasing: {
-            receiver: '@receiver',
-            params: ['@object'],
-            rest: null,
-            returns: '@returns',
-            temporaries: [],
-            effects: [
-              {
-                kind: 'Create',
-                into: '@returns',
-                reason: ValueReason.KnownReturnSignature,
-                value: ValueKind.Mutable,
-              },
-              // Object values are captured into the return
-              {
-                kind: 'Capture',
-                from: '@object',
-                into: '@returns',
-              },
-            ],
-          },
-        }),
-      ],
    ]),
  ],
  [
@@ -238,7 +132,7 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
        'from',
        addFunction(DEFAULT_SHAPES, [], {
          positionalParams: [
-            Effect.ConditionallyMutateIterator,
+            Effect.ConditionallyMutate,
            Effect.ConditionallyMutate,
            Effect.ConditionallyMutate,
          ],
@@ -478,150 +372,6 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
      returnValueKind: ValueKind.Primitive,
    }),
  ],
-  [
-    'parseInt',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'parseFloat',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'isNaN',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'isFinite',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'encodeURI',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'encodeURIComponent',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'decodeURI',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'decodeURIComponent',
-    addFunction(DEFAULT_SHAPES, [], {
-      positionalParams: [],
-      restParam: Effect.Read,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'Map',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInMapId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
-  [
-    'Set',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInSetId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
-  [
-    'WeakMap',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInWeakMapId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
-  [
-    'WeakSet',
-    addFunction(
-      DEFAULT_SHAPES,
-      [],
-      {
-        positionalParams: [Effect.ConditionallyMutateIterator],
-        restParam: null,
-        returnType: {kind: 'Object', shapeId: BuiltInWeakSetId},
-        calleeEffect: Effect.Read,
-        returnValueKind: ValueKind.Mutable,
-      },
-      null,
-      true,
-    ),
-  ],
  // TODO: rest of Global objects
 ];

@@ -738,41 +488,6 @@ const REACT_APIS: Array<[string, BuiltInType]> = [
        calleeEffect: Effect.Read,
        hookKind: 'useEffect',
        returnValueKind: ValueKind.Frozen,
-        aliasing: {
-          receiver: '@receiver',
-          params: [],
-          rest: '@rest',
-          returns: '@returns',
-          temporaries: ['@effect'],
-          effects: [
-            // Freezes the function and deps
-            {
-              kind: 'Freeze',
-              value: '@rest',
-              reason: ValueReason.Effect,
-            },
-            // Internally creates an effect object that captures the function and deps
-            {
-              kind: 'Create',
-              into: '@effect',
-              value: ValueKind.Frozen,
-              reason: ValueReason.KnownReturnSignature,
-            },
-            // The effect stores the function and dependencies
-            {
-              kind: 'Capture',
-              from: '@rest',
-              into: '@effect',
-            },
-            // Returns undefined
-            {
-              kind: 'Create',
-              into: '@returns',
-              value: ValueKind.Primitive,
-              reason: ValueReason.KnownReturnSignature,
-            },
-          ],
-        },
      },
      BuiltInUseEffectHookId,
    ),
@@ -841,40 +556,13 @@ const REACT_APIS: Array<[string, BuiltInType]> = [
      {
        positionalParams: [],
        restParam: null,
-        returnType: {
-          kind: 'Function',
-          return: {kind: 'Poly'},
-          shapeId: BuiltInFireFunctionId,
-          isConstructor: false,
-        },
+        returnType: {kind: 'Primitive'},
        calleeEffect: Effect.Read,
        returnValueKind: ValueKind.Frozen,
      },
      BuiltInFireId,
    ),
  ],
-  [
-    'useEffectEvent',
-    addHook(
-      DEFAULT_SHAPES,
-      {
-        positionalParams: [],
-        restParam: Effect.Freeze,
-        returnType: {
-          kind: 'Function',
-          return: {kind: 'Poly'},
-          shapeId: BuiltinEffectEventId,
-          isConstructor: false,
-        },
-        calleeEffect: Effect.Read,
-        hookKind: 'useEffectEvent',
-        // Frozen because it should not mutate any locally-bound values
-        returnValueKind: ValueKind.Frozen,
-      },
-      BuiltInUseEffectEventId,
-    ),
-  ],
-  ['AUTODEPS', addObject(DEFAULT_SHAPES, BuiltInAutodepsId, [])],
 ];

 TYPED_GLOBALS.push(
@@ -1000,7 +688,6 @@ export function installTypeConfig(
        noAlias: typeConfig.noAlias === true,
        mutableOnlyIfOperandsAreMutable:
          typeConfig.mutableOnlyIfOperandsAreMutable === true,
-        aliasing: typeConfig.aliasing,
      });
    }
    case 'hook': {
@@ -1018,7 +705,6 @@ export function installTypeConfig(
        ),
        returnValueKind: typeConfig.returnValueKind ?? ValueKind.Frozen,
        noAlias: typeConfig.noAlias === true,
-        aliasing: typeConfig.aliasing,
      });
    }
    case 'object': {
@@ -1098,7 +784,7 @@ export function getReanimatedModuleType(registry: ShapeRegistry): ObjectType {
      addHook(registry, {
        positionalParams: [],
        restParam: Effect.Freeze,
-        returnType: {kind: 'Object', shapeId: ReanimatedSharedValueId},
+        returnType: {kind: 'Poly'},
        returnValueKind: ValueKind.Mutable,
        noAlias: true,
        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
@@ -7,14 +7,12 @@

 import {BindingKind} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerError} from '../CompilerError';
+import {CompilerError, CompilerErrorDetailOptions} from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
 import {Environment, ReactFunctionType} from './Environment';
-import type {HookKind} from './ObjectShape';
+import {HookKind} from './ObjectShape';
 import {Type, makeType} from './Types';
 import {z} from 'zod';
-import type {AliasingEffect} from '../Inference/AliasingEffects';
-import {isReservedWord} from '../Utils/Keyword';

 /*
 * *******************************************************************************************
@@ -102,7 +100,6 @@ export type ReactiveInstruction = {
  id: InstructionId;
  lvalue: Place | null;
  value: ReactiveValue;
-  effects?: Array<AliasingEffect> | null; // TODO make non-optional
  loc: SourceLocation;
 };

@@ -280,15 +277,31 @@ export type HIRFunction = {
  env: Environment;
  params: Array<Place | SpreadPattern>;
  returnTypeAnnotation: t.FlowType | t.TSType | null;
-  returns: Place;
+  returnType: Type;
  context: Array<Place>;
+  effects: Array<FunctionEffect> | null;
  body: HIR;
  generator: boolean;
  async: boolean;
  directives: Array<string>;
-  aliasingEffects: Array<AliasingEffect> | null;
 };

+export type FunctionEffect =
+  | {
+      kind: 'GlobalMutation';
+      error: CompilerErrorDetailOptions;
+    }
+  | {
+      kind: 'ReactMutation';
+      error: CompilerErrorDetailOptions;
+    }
+  | {
+      kind: 'ContextMutation';
+      places: ReadonlySet<Place>;
+      effect: Effect;
+      loc: SourceLocation;
+    };
+
 /*
 * Each reactive scope may have its own control-flow, so the instructions form
 * a control-flow graph. The graph comprises a set of basic blocks which reference
@@ -430,25 +443,12 @@ export type ThrowTerminal = {
 };
 export type Case = {test: Place | null; block: BlockId};

-export type ReturnVariant = 'Void' | 'Implicit' | 'Explicit';
 export type ReturnTerminal = {
  kind: 'return';
-  /**
-   * Void:
-   *   () => { ... }
-   *   function() { ... }
-   * Implicit (ArrowFunctionExpression only):
-   *   () => foo
-   * Explicit:
-   *   () => { return ... }
-   *   function () { return ... }
-   */
-  returnVariant: ReturnVariant;
  loc: SourceLocation;
  value: Place;
  id: InstructionId;
  fallthrough?: never;
-  effects: Array<AliasingEffect> | null;
 };

 export type GotoTerminal = {
@@ -609,7 +609,6 @@ export type MaybeThrowTerminal = {
  id: InstructionId;
  loc: SourceLocation;
  fallthrough?: never;
-  effects: Array<AliasingEffect> | null;
 };

 export type ReactiveScopeTerminal = {
@@ -646,14 +645,12 @@ export type Instruction = {
  lvalue: Place;
  value: InstructionValue;
  loc: SourceLocation;
-  effects: Array<AliasingEffect> | null;
 };

 export type TInstruction<T extends InstructionValue> = {
  id: InstructionId;
  lvalue: Place;
  value: T;
-  effects: Array<AliasingEffect> | null;
  loc: SourceLocation;
 };

@@ -749,27 +746,6 @@ export enum InstructionKind {
  Function = 'Function',
 }

-export function convertHoistedLValueKind(
-  kind: InstructionKind,
-): InstructionKind | null {
-  switch (kind) {
-    case InstructionKind.HoistedLet:
-      return InstructionKind.Let;
-    case InstructionKind.HoistedConst:
-      return InstructionKind.Const;
-    case InstructionKind.HoistedFunction:
-      return InstructionKind.Function;
-    case InstructionKind.Let:
-    case InstructionKind.Const:
-    case InstructionKind.Function:
-    case InstructionKind.Reassign:
-    case InstructionKind.Catch:
-      return null;
-    default:
-      assertExhaustive(kind, 'Unexpected lvalue kind');
-  }
-}
-
 function _staticInvariantInstructionValueHasLocation(
  value: InstructionValue,
 ): SourceLocation {
@@ -853,13 +829,6 @@ export type CallExpression = {
  typeArguments?: Array<t.FlowType>;
 };

-export type NewExpression = {
-  kind: 'NewExpression';
-  callee: Place;
-  args: Array<Place | SpreadPattern>;
-  loc: SourceLocation;
-};
-
 export type LoadLocal = {
  kind: 'LoadLocal';
  place: Place;
@@ -904,20 +873,8 @@ export type InstructionValue =
  | StoreLocal
  | {
      kind: 'StoreContext';
-      /**
-       * StoreContext kinds:
-       * Reassign: context variable reassignment in source
-       * Const:    const declaration + assignment in source
-       *           ('const' context vars are ones whose declarations are hoisted)
-       * Let:      let declaration + assignment in source
-       * Function: function declaration in source (similar to `const`)
-       */
      lvalue: {
-        kind:
-          | InstructionKind.Reassign
-          | InstructionKind.Const
-          | InstructionKind.Let
-          | InstructionKind.Function;
+        kind: InstructionKind.Reassign;
        place: Place;
      };
      value: Place;
@@ -937,7 +894,12 @@ export type InstructionValue =
      right: Place;
      loc: SourceLocation;
    }
-  | NewExpression
+  | {
+      kind: 'NewExpression';
+      callee: Place;
+      args: Array<Place | SpreadPattern>;
+      loc: SourceLocation;
+    }
  | CallExpression
  | MethodCall
  | {
@@ -946,21 +908,13 @@ export type InstructionValue =
      value: Place;
      loc: SourceLocation;
    }
-  | ({
+  | {
      kind: 'TypeCastExpression';
      value: Place;
+      typeAnnotation: t.FlowType | t.TSType;
      type: Type;
      loc: SourceLocation;
-    } & (
-      | {
-          typeAnnotation: t.FlowType;
-          typeAnnotationKind: 'cast';
-        }
-      | {
-          typeAnnotation: t.TSType;
-          typeAnnotationKind: 'as' | 'satisfies';
-        }
-    ))
+    }
  | JsxExpression
  | {
      kind: 'ObjectExpression';
@@ -1211,21 +1165,18 @@ export type VariableBinding =
  // bindings declard outside the current component/hook
  | NonLocalBinding;

-// `import {bar as baz} from 'foo'`: name=baz, module=foo, imported=bar
-export type NonLocalImportSpecifier = {
-  kind: 'ImportSpecifier';
-  name: string;
-  module: string;
-  imported: string;
-};
-
 export type NonLocalBinding =
  // `import Foo from 'foo'`: name=Foo, module=foo
  | {kind: 'ImportDefault'; name: string; module: string}
  // `import * as Foo from 'foo'`: name=Foo, module=foo
  | {kind: 'ImportNamespace'; name: string; module: string}
-  // `import {bar as baz} from 'foo'`
-  | NonLocalImportSpecifier
+  // `import {bar as baz} from 'foo'`: name=baz, module=foo, imported=bar
+  | {
+      kind: 'ImportSpecifier';
+      name: string;
+      module: string;
+      imported: string;
+    }
  // let, const, function, etc declared in the module but outside the current component/hook
  | {kind: 'ModuleLocal'; name: string}
  // an unresolved binding
@@ -1304,21 +1255,12 @@ export function forkTemporaryIdentifier(
 * original source code.
 */
 export function makeIdentifierName(name: string): ValidatedIdentifier {
-  if (isReservedWord(name)) {
-    CompilerError.throwInvalidJS({
-      reason: 'Expected a non-reserved identifier name',
-      loc: GeneratedSource,
-      description: `\`${name}\` is a reserved word in JavaScript and cannot be used as an identifier name`,
-      suggestions: null,
-    });
-  } else {
-    CompilerError.invariant(t.isValidIdentifier(name), {
-      reason: `Expected a valid identifier name`,
-      loc: GeneratedSource,
-      description: `\`${name}\` is not a valid JavaScript identifier`,
-      suggestions: null,
-    });
-  }
+  CompilerError.invariant(t.isValidIdentifier(name), {
+    reason: `Expected a valid identifier name`,
+    loc: GeneratedSource,
+    description: `\`${name}\` is not a valid JavaScript identifier`,
+    suggestions: null,
+  });
  return {
    kind: 'named',
    value: name as ValidIdentifierName,
@@ -1392,21 +1334,6 @@ export enum ValueReason {
   */
  JsxCaptured = 'jsx-captured',

-  /**
-   * Argument to a hook
-   */
-  HookCaptured = 'hook-captured',
-
-  /**
-   * Return value of a hook
-   */
-  HookReturn = 'hook-return',
-
-  /**
-   * Passed to an effect
-   */
-  Effect = 'effect',
-
  /**
   * Return value of a function with known frozen return value, e.g. `useState`.
   */
@@ -1457,20 +1384,6 @@ export const ValueKindSchema = z.enum([
  ValueKind.Context,
 ]);

-export const ValueReasonSchema = z.enum([
-  ValueReason.Context,
-  ValueReason.Effect,
-  ValueReason.Global,
-  ValueReason.HookCaptured,
-  ValueReason.HookReturn,
-  ValueReason.JsxCaptured,
-  ValueReason.KnownReturnSignature,
-  ValueReason.Other,
-  ValueReason.ReactiveFunctionArgument,
-  ValueReason.ReducerState,
-  ValueReason.State,
-]);
-
 // The effect with which a value is modified.
 export enum Effect {
  // Default value: not allowed after lifetime inference
@@ -1481,7 +1394,6 @@ export enum Effect {
  Read = 'read',
  // This reference reads and stores the value
  Capture = 'capture',
-  ConditionallyMutateIterator = 'mutate-iterator?',
  /*
   * This reference *may* write to (mutate) the value. This covers two similar cases:
   * - The compiler is being conservative and assuming that a value *may* be mutated
@@ -1500,11 +1412,11 @@ export enum Effect {
  // This reference may alias to (mutate) the value
  Store = 'store',
 }
+
 export const EffectSchema = z.enum([
  Effect.Read,
  Effect.Mutate,
  Effect.ConditionallyMutate,
-  Effect.ConditionallyMutateIterator,
  Effect.Capture,
  Effect.Store,
  Effect.Freeze,
@@ -1518,7 +1430,6 @@ export function isMutableEffect(
    case Effect.Capture:
    case Effect.Store:
    case Effect.ConditionallyMutate:
-    case Effect.ConditionallyMutateIterator:
    case Effect.Mutate: {
      return true;
    }
@@ -1609,18 +1520,6 @@ export type DependencyPathEntry = {
 export type DependencyPath = Array<DependencyPathEntry>;
 export type ReactiveScopeDependency = {
  identifier: Identifier;
-  /**
-   * Reflects whether the base identifier is reactive. Note that some reactive
-   * objects may have non-reactive properties, but we do not currently track
-   * this.
-   *
-   * ```js
-   * // Technically, result[0] is reactive and result[1] is not.
-   * // Currently, both dependencies would be marked as reactive.
-   * const result = useState();
-   * ```
-   */
-  reactive: boolean;
  path: DependencyPath;
 };

@@ -1750,14 +1649,6 @@ export function isArrayType(id: Identifier): boolean {
  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInArray';
 }

-export function isMapType(id: Identifier): boolean {
-  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInMap';
-}
-
-export function isSetType(id: Identifier): boolean {
-  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInSet';
-}
-
 export function isPropsType(id: Identifier): boolean {
  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInProps';
 }
@@ -1774,26 +1665,10 @@ export function isUseStateType(id: Identifier): boolean {
  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseState';
 }

-export function isJsxType(type: Type): boolean {
-  return type.kind === 'Object' && type.shapeId === 'BuiltInJsx';
-}
-
 export function isRefOrRefValue(id: Identifier): boolean {
  return isUseRefType(id) || isRefValueType(id);
 }

-/*
- * Returns true if the type is a Ref or a custom user type that acts like a ref when it
- * shouldn't. For now the only other case of this is Reanimated's shared values.
- */
-export function isRefOrRefLikeMutableType(type: Type): boolean {
-  return (
-    type.kind === 'Object' &&
-    (type.shapeId === 'BuiltInUseRefId' ||
-      type.shapeId == 'ReanimatedSharedValueId')
-  );
-}
-
 export function isSetStateType(id: Identifier): boolean {
  return id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetState';
 }
@@ -1824,19 +1699,6 @@ export function isDispatcherType(id: Identifier): boolean {
  return id.type.kind === 'Function' && id.type.shapeId === 'BuiltInDispatch';
 }

-export function isFireFunctionType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Function' && id.type.shapeId === 'BuiltInFireFunction'
-  );
-}
-
-export function isEffectEventFunctionType(id: Identifier): boolean {
-  return (
-    id.type.kind === 'Function' &&
-    id.type.shapeId === 'BuiltInEffectEventFunction'
-  );
-}
-
 export function isStableType(id: Identifier): boolean {
  return (
    isSetStateType(id) ||
@@ -1847,40 +1709,6 @@ export function isStableType(id: Identifier): boolean {
  );
 }

-export function isStableTypeContainer(id: Identifier): boolean {
-  const type_ = id.type;
-  if (type_.kind !== 'Object') {
-    return false;
-  }
-  return (
-    isUseStateType(id) || // setState
-    type_.shapeId === 'BuiltInUseActionState' || // setActionState
-    isUseReducerType(id) || // dispatcher
-    type_.shapeId === 'BuiltInUseTransition' // startTransition
-  );
-}
-
-export function evaluatesToStableTypeOrContainer(
-  env: Environment,
-  {value}: Instruction,
-): boolean {
-  if (value.kind === 'CallExpression' || value.kind === 'MethodCall') {
-    const callee =
-      value.kind === 'CallExpression' ? value.callee : value.property;
-
-    const calleeHookKind = getHookKind(env, callee.identifier);
-    switch (calleeHookKind) {
-      case 'useState':
-      case 'useReducer':
-      case 'useActionState':
-      case 'useRef':
-      case 'useTransition':
-        return true;
-    }
-  }
-  return false;
-}
-
 export function isUseEffectHookType(id: Identifier): boolean {
  return (
    id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseEffectHook'
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts
@@ -7,7 +7,7 @@

 import {Binding, NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
+import {CompilerError} from '../CompilerError';
 import {Environment} from './Environment';
 import {
  BasicBlock,
@@ -106,10 +106,11 @@ export default class HIRBuilder {
  #current: WipBlock;
  #entry: BlockId;
  #scopes: Array<Scope> = [];
-  #context: Map<t.Identifier, SourceLocation>;
+  #context: Array<t.Identifier>;
  #bindings: Bindings;
  #env: Environment;
  #exceptionHandlerStack: Array<BlockId> = [];
+  parentFunction: NodePath<t.Function>;
  errors: CompilerError = new CompilerError();
  /**
   * Traversal context: counts the number of `fbt` tag parents
@@ -121,7 +122,7 @@ export default class HIRBuilder {
    return this.#env.nextIdentifierId;
  }

-  get context(): Map<t.Identifier, SourceLocation> {
+  get context(): Array<t.Identifier> {
    return this.#context;
  }

@@ -135,17 +136,16 @@ export default class HIRBuilder {

  constructor(
    env: Environment,
-    options?: {
-      bindings?: Bindings | null;
-      context?: Map<t.Identifier, SourceLocation>;
-      entryBlockKind?: BlockKind;
-    },
+    parentFunction: NodePath<t.Function>, // the outermost function being compiled
+    bindings: Bindings | null = null,
+    context: Array<t.Identifier> | null = null,
  ) {
    this.#env = env;
-    this.#bindings = options?.bindings ?? new Map();
-    this.#context = options?.context ?? new Map();
+    this.#bindings = bindings ?? new Map();
+    this.parentFunction = parentFunction;
+    this.#context = context ?? [];
    this.#entry = makeBlockId(env.nextBlockId);
-    this.#current = newBlock(this.#entry, options?.entryBlockKind ?? 'block');
+    this.#current = newBlock(this.#entry, 'block');
  }

  currentBlockKind(): BlockKind {
@@ -165,7 +165,6 @@ export default class HIRBuilder {
          handler: exceptionHandler,
          id: makeInstructionId(0),
          loc: instruction.loc,
-          effects: null,
        },
        continuationBlock,
      );
@@ -240,7 +239,7 @@ export default class HIRBuilder {

    // Check if the binding is from module scope
    const outerBinding =
-      this.#env.parentFunction.scope.parent.getBinding(originalName);
+      this.parentFunction.scope.parent.getBinding(originalName);
    if (babelBinding === outerBinding) {
      const path = babelBinding.path;
      if (path.isImportDefaultSpecifier()) {
@@ -294,7 +293,7 @@ export default class HIRBuilder {
    const binding = this.#resolveBabelBinding(path);
    if (binding) {
      // Check if the binding is from module scope, if so return null
-      const outerBinding = this.#env.parentFunction.scope.parent.getBinding(
+      const outerBinding = this.parentFunction.scope.parent.getBinding(
        path.node.name,
      );
      if (binding === outerBinding) {
@@ -308,35 +307,9 @@ export default class HIRBuilder {

  resolveBinding(node: t.Identifier): Identifier {
    if (node.name === 'fbt') {
-      CompilerError.throwDiagnostic({
-        severity: ErrorSeverity.Todo,
-        category: ErrorCategory.FBT,
-        reason: 'Support local variables named `fbt`',
-        description:
-          'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
-        details: [
-          {
-            kind: 'error',
-            message: 'Rename to avoid conflict with fbt plugin',
-            loc: node.loc ?? GeneratedSource,
-          },
-        ],
-      });
-    }
-    if (node.name === 'this') {
-      CompilerError.throwDiagnostic({
-        severity: ErrorSeverity.UnsupportedJS,
-        category: ErrorCategory.UnsupportedSyntax,
-        reason: '`this` is not supported syntax',
-        description:
-          'React Compiler does not support compiling functions that use `this`',
-        details: [
-          {
-            kind: 'error',
-            message: '`this` was used here',
-            loc: node.loc ?? GeneratedSource,
-          },
-        ],
+      CompilerError.throwTodo({
+        reason: 'Support local variables named "fbt"',
+        loc: node.loc ?? null,
      });
    }
    const originalName = node.name;
@@ -358,7 +331,6 @@ export default class HIRBuilder {
          type: makeType(),
          loc: node.loc ?? GeneratedSource,
        };
-        this.#env.programContext.addNewReference(name);
        this.#bindings.set(name, {node, identifier});
        return identifier;
      } else if (mapping.node === node) {
@@ -403,7 +375,7 @@ export default class HIRBuilder {
  }

  // Terminate the current block w the given terminal, and start a new block
-  terminate(terminal: Terminal, nextBlockKind: BlockKind | null): BlockId {
+  terminate(terminal: Terminal, nextBlockKind: BlockKind | null): void {
    const {id: blockId, kind, instructions} = this.#current;
    this.#completed.set(blockId, {
      kind,
@@ -417,7 +389,6 @@ export default class HIRBuilder {
      const nextId = this.#env.nextBlockId;
      this.#current = newBlock(nextId, nextBlockKind);
    }
-    return blockId;
  }

  /*
@@ -774,11 +745,6 @@ function getReversePostorderedBlocks(func: HIR): HIR['blocks'] {
     * (eg bb2 then bb1), we ensure that they get reversed back to the correct order.
     */
    const block = func.blocks.get(blockId)!;
-    CompilerError.invariant(block != null, {
-      reason: '[HIRBuilder] Unexpected null block',
-      description: `expected block ${blockId} to exist`,
-      loc: GeneratedSource,
-    });
    const successors = [...eachTerminalSuccessor(block.terminal)].reverse();
    const fallthrough = terminalFallthrough(block.terminal);

--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/MergeConsecutiveBlocks.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/MergeConsecutiveBlocks.ts
@@ -12,7 +12,6 @@ import {
  GeneratedSource,
  HIRFunction,
  Instruction,
-  Place,
 } from './HIR';
 import {markPredecessors} from './HIRBuilder';
 import {terminalFallthrough, terminalHasFallthrough} from './visitors';
@@ -81,22 +80,20 @@ export function mergeConsecutiveBlocks(fn: HIRFunction): void {
        suggestions: null,
      });
      const operand = Array.from(phi.operands.values())[0]!;
-      const lvalue: Place = {
-        kind: 'Identifier',
-        identifier: phi.place.identifier,
-        effect: Effect.ConditionallyMutate,
-        reactive: false,
-        loc: GeneratedSource,
-      };
      const instr: Instruction = {
        id: predecessor.terminal.id,
-        lvalue: {...lvalue},
+        lvalue: {
+          kind: 'Identifier',
+          identifier: phi.place.identifier,
+          effect: Effect.ConditionallyMutate,
+          reactive: false,
+          loc: GeneratedSource,
+        },
        value: {
          kind: 'LoadLocal',
          place: {...operand},
          loc: GeneratedSource,
        },
-        effects: [{kind: 'Alias', from: {...operand}, into: {...lvalue}}],
        loc: GeneratedSource,
      };
      predecessor.instructions.push(instr);
@@ -107,17 +104,6 @@ export function mergeConsecutiveBlocks(fn: HIRFunction): void {
    merged.merge(block.id, predecessorId);
    fn.body.blocks.delete(block.id);
  }
-  for (const [, block] of fn.body.blocks) {
-    for (const phi of block.phis) {
-      for (const [predecessorId, operand] of phi.operands) {
-        const mapped = merged.get(predecessorId);
-        if (mapped !== predecessorId) {
-          phi.operands.delete(predecessorId);
-          phi.operands.set(mapped, operand);
-        }
-      }
-    }
-  }
  markPredecessors(fn.body);
  for (const [, {terminal}] of fn.body.blocks) {
    if (terminalHasFallthrough(terminal)) {
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/MergeOverlappingReactiveScopesHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/MergeOverlappingReactiveScopesHIR.ts
@@ -1,10 +1,3 @@
-/**
- * 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 {
  HIRFunction,
  InstructionId,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts
@@ -6,30 +6,14 @@
 */

 import {CompilerError} from '../CompilerError';
-import {AliasingEffect, AliasingSignature} from '../Inference/AliasingEffects';
-import {assertExhaustive} from '../Utils/utils';
-import {
-  Effect,
-  GeneratedSource,
-  Hole,
-  makeDeclarationId,
-  makeIdentifierId,
-  makeInstructionId,
-  Place,
-  SourceLocation,
-  SpreadPattern,
-  ValueKind,
-  ValueReason,
-} from './HIR';
+import {Effect, ValueKind, ValueReason} from './HIR';
 import {
  BuiltInType,
  FunctionType,
-  makeType,
  ObjectType,
  PolyType,
  PrimitiveType,
 } from './Types';
-import {AliasingEffectConfig, AliasingSignatureConfig} from './TypeSchema';

 /*
 * This file exports types and defaults for JavaScript object shapes. These are
@@ -58,27 +42,18 @@ function createAnonId(): string {
 export function addFunction(
  registry: ShapeRegistry,
  properties: Iterable<[string, BuiltInType | PolyType]>,
-  fn: Omit<FunctionSignature, 'hookKind' | 'aliasing'> & {
-    aliasing?: AliasingSignatureConfig | null | undefined;
-  },
+  fn: Omit<FunctionSignature, 'hookKind'>,
  id: string | null = null,
-  isConstructor: boolean = false,
 ): FunctionType {
  const shapeId = id ?? createAnonId();
-  const aliasing =
-    fn.aliasing != null
-      ? parseAliasingSignatureConfig(fn.aliasing, '<builtin>', GeneratedSource)
-      : null;
  addShape(registry, shapeId, properties, {
    ...fn,
-    aliasing,
    hookKind: null,
  });
  return {
    kind: 'Function',
    return: fn.returnType,
    shapeId,
-    isConstructor,
  };
 }

@@ -89,147 +64,15 @@ export function addFunction(
 */
 export function addHook(
  registry: ShapeRegistry,
-  fn: Omit<FunctionSignature, 'aliasing'> & {
-    hookKind: HookKind;
-    aliasing?: AliasingSignatureConfig | null | undefined;
-  },
+  fn: FunctionSignature & {hookKind: HookKind},
  id: string | null = null,
 ): FunctionType {
  const shapeId = id ?? createAnonId();
-  const aliasing =
-    fn.aliasing != null
-      ? parseAliasingSignatureConfig(fn.aliasing, '<builtin>', GeneratedSource)
-      : null;
-  addShape(registry, shapeId, [], {...fn, aliasing});
+  addShape(registry, shapeId, [], fn);
  return {
    kind: 'Function',
    return: fn.returnType,
    shapeId,
-    isConstructor: false,
-  };
-}
-
-function parseAliasingSignatureConfig(
-  typeConfig: AliasingSignatureConfig,
-  moduleName: string,
-  loc: SourceLocation,
-): AliasingSignature {
-  const lifetimes = new Map<string, Place>();
-  function define(temp: string): Place {
-    CompilerError.invariant(!lifetimes.has(temp), {
-      reason: `Invalid type configuration for module`,
-      description: `Expected aliasing signature to have unique names for receiver, params, rest, returns, and temporaries in module '${moduleName}'`,
-      loc,
-    });
-    const place = signatureArgument(lifetimes.size);
-    lifetimes.set(temp, place);
-    return place;
-  }
-  function lookup(temp: string): Place {
-    const place = lifetimes.get(temp);
-    CompilerError.invariant(place != null, {
-      reason: `Invalid type configuration for module`,
-      description: `Expected aliasing signature effects to reference known names from receiver/params/rest/returns/temporaries, but '${temp}' is not a known name in '${moduleName}'`,
-      loc,
-    });
-    return place;
-  }
-  const receiver = define(typeConfig.receiver);
-  const params = typeConfig.params.map(define);
-  const rest = typeConfig.rest != null ? define(typeConfig.rest) : null;
-  const returns = define(typeConfig.returns);
-  const temporaries = typeConfig.temporaries.map(define);
-  const effects = typeConfig.effects.map(
-    (effect: AliasingEffectConfig): AliasingEffect => {
-      switch (effect.kind) {
-        case 'ImmutableCapture':
-        case 'CreateFrom':
-        case 'Capture':
-        case 'Alias':
-        case 'Assign': {
-          const from = lookup(effect.from);
-          const into = lookup(effect.into);
-          return {
-            kind: effect.kind,
-            from,
-            into,
-          };
-        }
-        case 'Mutate':
-        case 'MutateTransitiveConditionally': {
-          const value = lookup(effect.value);
-          return {kind: effect.kind, value};
-        }
-        case 'Create': {
-          const into = lookup(effect.into);
-          return {
-            kind: 'Create',
-            into,
-            reason: effect.reason,
-            value: effect.value,
-          };
-        }
-        case 'Freeze': {
-          const value = lookup(effect.value);
-          return {
-            kind: 'Freeze',
-            value,
-            reason: effect.reason,
-          };
-        }
-        case 'Impure': {
-          const place = lookup(effect.place);
-          return {
-            kind: 'Impure',
-            place,
-            error: CompilerError.throwTodo({
-              reason: 'Support impure effect declarations',
-              loc: GeneratedSource,
-            }),
-          };
-        }
-        case 'Apply': {
-          const receiver = lookup(effect.receiver);
-          const fn = lookup(effect.function);
-          const args: Array<Place | SpreadPattern | Hole> = effect.args.map(
-            arg => {
-              if (typeof arg === 'string') {
-                return lookup(arg);
-              } else if (arg.kind === 'Spread') {
-                return {kind: 'Spread', place: lookup(arg.place)};
-              } else {
-                return arg;
-              }
-            },
-          );
-          const into = lookup(effect.into);
-          return {
-            kind: 'Apply',
-            receiver,
-            function: fn,
-            mutatesFunction: effect.mutatesFunction,
-            args,
-            into,
-            loc,
-            signature: null,
-          };
-        }
-        default: {
-          assertExhaustive(
-            effect,
-            `Unexpected effect kind '${(effect as any).kind}'`,
-          );
-        }
-      }
-    },
-  );
-  return {
-    receiver: receiver.identifier.id,
-    params: params.map(p => p.identifier.id),
-    rest: rest != null ? rest.identifier.id : null,
-    returns: returns.identifier.id,
-    temporaries,
-    effects,
  };
 }

@@ -285,7 +128,6 @@ export type HookKind =
  | 'useCallback'
  | 'useTransition'
  | 'useImperativeHandle'
-  | 'useEffectEvent'
  | 'Custom';

 /*
@@ -334,8 +176,6 @@ export type FunctionSignature = {
  impure?: boolean;

  canonicalName?: string;
-
-  aliasing?: AliasingSignature | null | undefined;
 };

 /*
@@ -358,10 +198,6 @@ export type ObjectShape = {
 export type ShapeRegistry = Map<string, ObjectShape>;
 export const BuiltInPropsId = 'BuiltInProps';
 export const BuiltInArrayId = 'BuiltInArray';
-export const BuiltInSetId = 'BuiltInSet';
-export const BuiltInMapId = 'BuiltInMap';
-export const BuiltInWeakSetId = 'BuiltInWeakSet';
-export const BuiltInWeakMapId = 'BuiltInWeakMap';
 export const BuiltInFunctionId = 'BuiltInFunction';
 export const BuiltInJsxId = 'BuiltInJsx';
 export const BuiltInObjectId = 'BuiltInObject';
@@ -382,13 +218,6 @@ export const BuiltInUseContextHookId = 'BuiltInUseContextHook';
 export const BuiltInUseTransitionId = 'BuiltInUseTransition';
 export const BuiltInStartTransitionId = 'BuiltInStartTransition';
 export const BuiltInFireId = 'BuiltInFire';
-export const BuiltInFireFunctionId = 'BuiltInFireFunction';
-export const BuiltInUseEffectEventId = 'BuiltInUseEffectEvent';
-export const BuiltinEffectEventId = 'BuiltInEffectEventFunction';
-export const BuiltInAutodepsId = 'BuiltInAutoDepsId';
-
-// See getReanimatedModuleType() in Globals.ts — this is part of supporting Reanimated's ref-like types
-export const ReanimatedSharedValueId = 'ReanimatedSharedValueId';

 // ShapeRegistry with default definitions for built-ins.
 export const BUILTIN_SHAPES: ShapeRegistry = new Map();
@@ -462,30 +291,6 @@ addObject(BUILTIN_SHAPES, BuiltInArrayId, [
      returnType: PRIMITIVE_TYPE,
      calleeEffect: Effect.Store,
      returnValueKind: ValueKind.Primitive,
-      aliasing: {
-        receiver: '@receiver',
-        params: [],
-        rest: '@rest',
-        returns: '@returns',
-        temporaries: [],
-        effects: [
-          // Push directly mutates the array itself
-          {kind: 'Mutate', value: '@receiver'},
-          // The arguments are captured into the array
-          {
-            kind: 'Capture',
-            from: '@rest',
-            into: '@receiver',
-          },
-          // Returns the new length, a primitive
-          {
-            kind: 'Create',
-            into: '@returns',
-            value: ValueKind.Primitive,
-            reason: ValueReason.KnownReturnSignature,
-          },
-        ],
-      },
    }),
  ],
  [
@@ -516,60 +321,6 @@ addObject(BUILTIN_SHAPES, BuiltInArrayId, [
      returnValueKind: ValueKind.Mutable,
      noAlias: true,
      mutableOnlyIfOperandsAreMutable: true,
-      aliasing: {
-        receiver: '@receiver',
-        params: ['@callback'],
-        rest: null,
-        returns: '@returns',
-        temporaries: [
-          // Temporary representing captured items of the receiver
-          '@item',
-          // Temporary representing the result of the callback
-          '@callbackReturn',
-          /*
-           * Undefined `this` arg to the callback. Note the signature does not
-           * support passing an explicit thisArg second param
-           */
-          '@thisArg',
-        ],
-        effects: [
-          // Map creates a new mutable array
-          {
-            kind: 'Create',
-            into: '@returns',
-            value: ValueKind.Mutable,
-            reason: ValueReason.KnownReturnSignature,
-          },
-          // The first arg to the callback is an item extracted from the receiver array
-          {
-            kind: 'CreateFrom',
-            from: '@receiver',
-            into: '@item',
-          },
-          // The undefined this for the callback
-          {
-            kind: 'Create',
-            into: '@thisArg',
-            value: ValueKind.Primitive,
-            reason: ValueReason.KnownReturnSignature,
-          },
-          // calls the callback, returning the result into a temporary
-          {
-            kind: 'Apply',
-            receiver: '@thisArg',
-            args: ['@item', {kind: 'Hole'}, '@receiver'],
-            function: '@callback',
-            into: '@callbackReturn',
-            mutatesFunction: false,
-          },
-          // captures the result of the callback into the return array
-          {
-            kind: 'Capture',
-            from: '@callbackReturn',
-            into: '@returns',
-          },
-        ],
-      },
    }),
  ],
  [
@@ -700,434 +451,6 @@ addObject(BUILTIN_SHAPES, BuiltInObjectId, [
   */
 ]);

-/* Built-in Set shape */
-addObject(BUILTIN_SHAPES, BuiltInSetId, [
-  [
-    /**
-     * add(value)
-     * Parameters
-     *   value: the value of the element to add to the Set object.
-     * Returns the Set object with added value.
-     */
-    'add',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Store,
-      // returnValueKind is technically dependent on the ValueKind of the set itself
-      returnValueKind: ValueKind.Mutable,
-      aliasing: {
-        receiver: '@receiver',
-        params: [],
-        rest: '@rest',
-        returns: '@returns',
-        temporaries: [],
-        effects: [
-          // Set.add returns the receiver Set
-          {
-            kind: 'Assign',
-            from: '@receiver',
-            into: '@returns',
-          },
-          // Set.add mutates the set itself
-          {
-            kind: 'Mutate',
-            value: '@receiver',
-          },
-          // Captures the rest params into the set
-          {
-            kind: 'Capture',
-            from: '@rest',
-            into: '@receiver',
-          },
-        ],
-      },
-    }),
-  ],
-  [
-    /**
-     * clear()
-     * Parameters none
-     * Returns undefined
-     */
-    'clear',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * setInstance.delete(value)
-     * Returns true if value was already in Set; otherwise false.
-     */
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  ['size', PRIMITIVE_TYPE],
-  [
-    /**
-     * difference(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns a new Set object containing elements in this set but not in the other set.
-     */
-    'difference',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * union(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns a new Set object containing elements in either this set or the other set.
-     */
-    'union',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * symmetricalDifference(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * A new Set object containing elements which are in either this set or the other set, but not in both.
-     */
-    'symmetricalDifference',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInSetId},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * isSubsetOf(other)
-     * Parameters
-     *   other: A Set object, or set-like object.
-     * Returns true if all elements in this set are also in the other set, and false otherwise.
-     */
-    'isSubsetOf',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * isSupersetOf(other)
-     * Parameters
-     *  other: A Set object, or set-like object.
-     * Returns true if all elements in the other set are also in this set, and false otherwise.
-     */
-    'isSupersetOf',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * forEach(callbackFn)
-     * forEach(callbackFn, thisArg)
-     */
-    'forEach',
-    addFunction(BUILTIN_SHAPES, [], {
-      /**
-       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
-       */
-      positionalParams: [],
-      restParam: Effect.ConditionallyMutate,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.ConditionallyMutate,
-      returnValueKind: ValueKind.Primitive,
-      noAlias: true,
-      mutableOnlyIfOperandsAreMutable: true,
-    }),
-  ],
-  /**
-   * Iterators
-   */
-  [
-    'entries',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'keys',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'values',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-addObject(BUILTIN_SHAPES, BuiltInMapId, [
-  [
-    /**
-     * clear()
-     * Parameters none
-     * Returns undefined
-     */
-    'clear',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'get',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * Params
-     *   key: the key of the element to add to the Map object. The key may be
-     *   any JavaScript type (any primitive value or any type of JavaScript
-     *   object).
-     *   value: the value of the element to add to the Map object.
-     * Returns the Map object.
-     */
-    'set',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture, Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInMapId},
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  ['size', PRIMITIVE_TYPE],
-  [
-    'forEach',
-    addFunction(BUILTIN_SHAPES, [], {
-      /**
-       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
-       */
-      positionalParams: [],
-      restParam: Effect.ConditionallyMutate,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.ConditionallyMutate,
-      returnValueKind: ValueKind.Primitive,
-      noAlias: true,
-      mutableOnlyIfOperandsAreMutable: true,
-    }),
-  ],
-  /**
-   * Iterators
-   */
-  [
-    'entries',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'keys',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'values',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-addObject(BUILTIN_SHAPES, BuiltInWeakSetId, [
-  [
-    /**
-     * add(value)
-     * Parameters
-     *   value: the value of the element to add to the Set object.
-     * Returns the Set object with added value.
-     */
-    'add',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInWeakSetId},
-      calleeEffect: Effect.Store,
-      // returnValueKind is technically dependent on the ValueKind of the set itself
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    /**
-     * setInstance.delete(value)
-     * Returns true if value was already in Set; otherwise false.
-     */
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-]);
-
-addObject(BUILTIN_SHAPES, BuiltInWeakMapId, [
-  [
-    'delete',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'get',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Capture,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'has',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: PRIMITIVE_TYPE,
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    /**
-     * Params
-     *   key: the key of the element to add to the Map object. The key may be
-     *   any JavaScript type (any primitive value or any type of JavaScript
-     *   object).
-     *   value: the value of the element to add to the Map object.
-     * Returns the Map object.
-     */
-    'set',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Capture, Effect.Capture],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInWeakMapId},
-      calleeEffect: Effect.Store,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
 addObject(BUILTIN_SHAPES, BuiltInUseStateId, [
  ['0', {kind: 'Poly'}],
  [
@@ -1212,21 +535,6 @@ addObject(BUILTIN_SHAPES, BuiltInRefValueId, [
  ['*', {kind: 'Object', shapeId: BuiltInRefValueId}],
 ]);

-addObject(BUILTIN_SHAPES, ReanimatedSharedValueId, []);
-
-addFunction(
-  BUILTIN_SHAPES,
-  [],
-  {
-    positionalParams: [],
-    restParam: Effect.ConditionallyMutate,
-    returnType: {kind: 'Poly'},
-    calleeEffect: Effect.ConditionallyMutate,
-    returnValueKind: ValueKind.Mutable,
-  },
-  BuiltinEffectEventId,
-);
-
 /**
 * MixedReadOnly =
 *   | primitive
@@ -1445,53 +753,6 @@ export const DefaultNonmutatingHook = addHook(
    calleeEffect: Effect.Read,
    hookKind: 'Custom',
    returnValueKind: ValueKind.Frozen,
-    aliasing: {
-      receiver: '@receiver',
-      params: [],
-      rest: '@rest',
-      returns: '@returns',
-      temporaries: [],
-      effects: [
-        // Freeze the arguments
-        {
-          kind: 'Freeze',
-          value: '@rest',
-          reason: ValueReason.HookCaptured,
-        },
-        // Returns a frozen value
-        {
-          kind: 'Create',
-          into: '@returns',
-          value: ValueKind.Frozen,
-          reason: ValueReason.HookReturn,
-        },
-        // May alias any arguments into the return
-        {
-          kind: 'Alias',
-          from: '@rest',
-          into: '@returns',
-        },
-      ],
-    },
  },
  'DefaultNonmutatingHook',
 );
-
-export function signatureArgument(id: number): Place {
-  const place: Place = {
-    kind: 'Identifier',
-    effect: Effect.Unknown,
-    loc: GeneratedSource,
-    reactive: false,
-    identifier: {
-      declarationId: makeDeclarationId(id),
-      id: makeIdentifierId(id),
-      loc: GeneratedSource,
-      mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
-      name: null,
-      scope: null,
-      type: makeType(),
-    },
-  };
-  return place;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/PrintHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/PrintHIR.ts
@@ -5,6 +5,7 @@
 * LICENSE file in the root directory of this source tree.
 */

+import generate from '@babel/generator';
 import {CompilerError} from '../CompilerError';
 import {printReactiveScopeSummary} from '../ReactiveScopes/PrintReactiveFunction';
 import DisjointSet from '../Utils/DisjointSet';
@@ -34,7 +35,6 @@ import type {
  Type,
 } from './HIR';
 import {GotoVariant, InstructionKind} from './HIR';
-import {AliasingEffect, AliasingSignature} from '../Inference/AliasingEffects';

 export type Options = {
  indent: number;
@@ -53,8 +53,6 @@ export function printFunction(fn: HIRFunction): string {
  let definition = '';
  if (fn.id !== null) {
    definition += fn.id;
-  } else {
-    definition += '<<anonymous>>';
  }
  if (fn.params.length !== 0) {
    definition +=
@@ -69,13 +67,13 @@ export function printFunction(fn: HIRFunction): string {
        })
        .join(', ') +
      ')';
-  } else {
-    definition += '()';
  }
-  definition += `: ${printPlace(fn.returns)}`;
-  output.push(definition);
-  output.push(...fn.directives);
+  if (definition.length !== 0) {
+    output.push(definition);
+  }
+  output.push(printType(fn.returnType));
  output.push(printHIR(fn.body));
+  output.push(...fn.directives);
  return output.join('\n');
 }

@@ -153,10 +151,7 @@ export function printMixedHIR(

 export function printInstruction(instr: ReactiveInstruction): string {
  const id = `[${instr.id}]`;
-  let value = printInstructionValue(instr.value);
-  if (instr.effects != null) {
-    value += `\n    ${instr.effects.map(printAliasingEffect).join('\n    ')}`;
-  }
+  const value = printInstructionValue(instr.value);

  if (instr.lvalue !== null) {
    return `${id} ${printPlace(instr.lvalue)} = ${value}`;
@@ -215,12 +210,9 @@ export function printTerminal(terminal: Terminal): Array<string> | string {
      break;
    }
    case 'return': {
-      value = `[${terminal.id}] Return ${terminal.returnVariant}${
+      value = `[${terminal.id}] Return${
        terminal.value != null ? ' ' + printPlace(terminal.value) : ''
      }`;
-      if (terminal.effects != null) {
-        value += `\n    ${terminal.effects.map(printAliasingEffect).join('\n    ')}`;
-      }
      break;
    }
    case 'goto': {
@@ -289,9 +281,6 @@ export function printTerminal(terminal: Terminal): Array<string> | string {
    }
    case 'maybe-throw': {
      value = `[${terminal.id}] MaybeThrow continuation=bb${terminal.continuation} handler=bb${terminal.handler}`;
-      if (terminal.effects != null) {
-        value += `\n    ${terminal.effects.map(printAliasingEffect).join('\n    ')}`;
-      }
      break;
    }
    case 'scope': {
@@ -465,7 +454,7 @@ export function printInstructionValue(instrValue: ReactiveValue): string {
      break;
    }
    case 'UnsupportedNode': {
-      value = `UnsupportedNode ${instrValue.node.type}`;
+      value = `UnsupportedNode(${generate(instrValue.node).code})`;
      break;
    }
    case 'LoadLocal': {
@@ -554,11 +543,20 @@ export function printInstructionValue(instrValue: ReactiveValue): string {
      const context = instrValue.loweredFunc.func.context
        .map(dep => printPlace(dep))
        .join(',');
-      const aliasingEffects =
-        instrValue.loweredFunc.func.aliasingEffects
-          ?.map(printAliasingEffect)
-          ?.join(', ') ?? '';
-      value = `${kind} ${name} @context[${context}] @aliasingEffects=[${aliasingEffects}]\n${fn}`;
+      const effects =
+        instrValue.loweredFunc.func.effects
+          ?.map(effect => {
+            if (effect.kind === 'ContextMutation') {
+              return `ContextMutation places=[${[...effect.places]
+                .map(place => printPlace(place))
+                .join(', ')}] effect=${effect.effect}`;
+            } else {
+              return `GlobalMutation`;
+            }
+          })
+          .join(', ') ?? '';
+      const type = printType(instrValue.loweredFunc.func.returnType).trim();
+      value = `${kind} ${name} @context[${context}] @effects[${effects}]${type !== '' ? ` return${type}` : ''}:\n${fn}`;
      break;
    }
    case 'TaggedTemplateExpression': {
@@ -702,7 +700,7 @@ export function printInstructionValue(instrValue: ReactiveValue): string {
      break;
    }
    case 'FinishMemoize': {
-      value = `FinishMemoize decl=${printPlace(instrValue.decl)}${instrValue.pruned ? ' pruned' : ''}`;
+      value = `FinishMemoize decl=${printPlace(instrValue.decl)}`;
      break;
    }
    default: {
@@ -880,8 +878,7 @@ export function printType(type: Type): string {
  if (type.kind === 'Object' && type.shapeId != null) {
    return `:T${type.kind}<${type.shapeId}>`;
  } else if (type.kind === 'Function' && type.shapeId != null) {
-    const returnType = printType(type.return);
-    return `:T${type.kind}<${type.shapeId}>()${returnType !== '' ? `:  ${returnType}` : ''}`;
+    return `:T${type.kind}<${type.shapeId}>`;
  } else {
    return `:T${type.kind}`;
  }
@@ -925,110 +922,3 @@ function getFunctionName(
      return defaultValue;
  }
 }
-
-export function printAliasingEffect(effect: AliasingEffect): string {
-  switch (effect.kind) {
-    case 'Assign': {
-      return `Assign ${printPlaceForAliasEffect(effect.into)} = ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'Alias': {
-      return `Alias ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'MaybeAlias': {
-      return `MaybeAlias ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'Capture': {
-      return `Capture ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'ImmutableCapture': {
-      return `ImmutableCapture ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'Create': {
-      return `Create ${printPlaceForAliasEffect(effect.into)} = ${effect.value}`;
-    }
-    case 'CreateFrom': {
-      return `Create ${printPlaceForAliasEffect(effect.into)} = kindOf(${printPlaceForAliasEffect(effect.from)})`;
-    }
-    case 'CreateFunction': {
-      return `Function ${printPlaceForAliasEffect(effect.into)} = Function captures=[${effect.captures.map(printPlaceForAliasEffect).join(', ')}]`;
-    }
-    case 'Apply': {
-      const receiverCallee =
-        effect.receiver.identifier.id === effect.function.identifier.id
-          ? printPlaceForAliasEffect(effect.receiver)
-          : `${printPlaceForAliasEffect(effect.receiver)}.${printPlaceForAliasEffect(effect.function)}`;
-      const args = effect.args
-        .map(arg => {
-          if (arg.kind === 'Identifier') {
-            return printPlaceForAliasEffect(arg);
-          } else if (arg.kind === 'Hole') {
-            return ' ';
-          }
-          return `...${printPlaceForAliasEffect(arg.place)}`;
-        })
-        .join(', ');
-      let signature = '';
-      if (effect.signature != null) {
-        if (effect.signature.aliasing != null) {
-          signature = printAliasingSignature(effect.signature.aliasing);
-        } else {
-          signature = JSON.stringify(effect.signature, null, 2);
-        }
-      }
-      return `Apply ${printPlaceForAliasEffect(effect.into)} = ${receiverCallee}(${args})${signature != '' ? '\n     ' : ''}${signature}`;
-    }
-    case 'Freeze': {
-      return `Freeze ${printPlaceForAliasEffect(effect.value)} ${effect.reason}`;
-    }
-    case 'Mutate':
-    case 'MutateConditionally':
-    case 'MutateTransitive':
-    case 'MutateTransitiveConditionally': {
-      return `${effect.kind} ${printPlaceForAliasEffect(effect.value)}${effect.kind === 'Mutate' && effect.reason?.kind === 'AssignCurrentProperty' ? ' (assign `.current`)' : ''}`;
-    }
-    case 'MutateFrozen': {
-      return `MutateFrozen ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
-    }
-    case 'MutateGlobal': {
-      return `MutateGlobal ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
-    }
-    case 'Impure': {
-      return `Impure ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
-    }
-    case 'Render': {
-      return `Render ${printPlaceForAliasEffect(effect.place)}`;
-    }
-    default: {
-      assertExhaustive(effect, `Unexpected kind '${(effect as any).kind}'`);
-    }
-  }
-}
-
-function printPlaceForAliasEffect(place: Place): string {
-  return printIdentifier(place.identifier);
-}
-
-export function printAliasingSignature(signature: AliasingSignature): string {
-  const tokens: Array<string> = ['function '];
-  if (signature.temporaries.length !== 0) {
-    tokens.push('<');
-    tokens.push(
-      signature.temporaries.map(temp => `$${temp.identifier.id}`).join(', '),
-    );
-    tokens.push('>');
-  }
-  tokens.push('(');
-  tokens.push('this=$' + String(signature.receiver));
-  for (const param of signature.params) {
-    tokens.push(', $' + String(param));
-  }
-  if (signature.rest != null) {
-    tokens.push(`, ...$${String(signature.rest)}`);
-  }
-  tokens.push('): ');
-  tokens.push('$' + String(signature.returns) + ':');
-  for (const effect of signature.effects) {
-    tokens.push('\n  ' + printAliasingEffect(effect));
-  }
-  return tokens.join('');
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/PropagateScopeDependenciesHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/PropagateScopeDependenciesHIR.ts
@@ -1,10 +1,3 @@
-/**
- * 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 {
  ScopeId,
  HIRFunction,
@@ -30,7 +23,6 @@ import {
  FunctionExpression,
  ObjectMethod,
  PropertyLiteral,
-  convertHoistedLValueKind,
 } from './HIR';
 import {
  collectHoistablePropertyLoads,
@@ -117,7 +109,7 @@ export function propagateScopeDependenciesHIR(fn: HIRFunction): void {
  }
 }

-export function findTemporariesUsedOutsideDeclaringScope(
+function findTemporariesUsedOutsideDeclaringScope(
  fn: HIRFunction,
 ): ReadonlySet<DeclarationId> {
  /*
@@ -247,18 +239,12 @@ function isLoadContextMutable(
  id: InstructionId,
 ): instrValue is LoadContext {
  if (instrValue.kind === 'LoadContext') {
-    /**
-     * Not all context variables currently have scopes due to limitations of
-     * mutability analysis for function expressions.
-     *
-     * Currently, many function expressions references are inferred to be
-     * 'Read' | 'Freeze' effects which don't replay mutable effects of captured
-     * context.
-     */
-    return (
-      instrValue.place.identifier.scope != null &&
-      id >= instrValue.place.identifier.scope.range.end
-    );
+    CompilerError.invariant(instrValue.place.identifier.scope != null, {
+      reason:
+        '[PropagateScopeDependencies] Expected all context variables to be assigned a scope',
+      loc: instrValue.loc,
+    });
+    return id >= instrValue.place.identifier.scope.range.end;
  }
  return false;
 }
@@ -316,7 +302,6 @@ function collectTemporariesSidemapImpl(
        ) {
          temporaries.set(lvalue.identifier.id, {
            identifier: value.place.identifier,
-            reactive: value.place.reactive,
            path: [],
          });
        }
@@ -370,13 +355,11 @@ function getProperty(
  if (resolvedDependency == null) {
    property = {
      identifier: object.identifier,
-      reactive: object.reactive,
      path: [{property: propertyName, optional}],
    };
  } else {
    property = {
      identifier: resolvedDependency.identifier,
-      reactive: resolvedDependency.reactive,
      path: [...resolvedDependency.path, {property: propertyName, optional}],
    };
  }
@@ -388,7 +371,7 @@ type Decl = {
  scope: Stack<ReactiveScope>;
 };

-export class DependencyCollectionContext {
+class Context {
  #declarations: Map<DeclarationId, Decl> = new Map();
  #reassignments: Map<Identifier, Decl> = new Map();

@@ -481,9 +464,6 @@ export class DependencyCollectionContext {
    }
    this.#reassignments.set(identifier, decl);
  }
-  hasDeclared(identifier: Identifier): boolean {
-    return this.#declarations.has(identifier.declarationId);
-  }

  // Checks if identifier is a valid dependency in the current scope
  #checkValidDependency(maybeDependency: ReactiveScopeDependency): boolean {
@@ -535,7 +515,6 @@ export class DependencyCollectionContext {
    this.visitDependency(
      this.#temporaries.get(place.identifier.id) ?? {
        identifier: place.identifier,
-        reactive: place.reactive,
        path: [],
      },
    );
@@ -600,7 +579,6 @@ export class DependencyCollectionContext {
    ) {
      maybeDependency = {
        identifier: maybeDependency.identifier,
-        reactive: maybeDependency.reactive,
        path: [],
      };
    }
@@ -622,11 +600,7 @@ export class DependencyCollectionContext {
        identifier =>
          identifier.declarationId === place.identifier.declarationId,
      ) &&
-      this.#checkValidDependency({
-        identifier: place.identifier,
-        reactive: place.reactive,
-        path: [],
-      })
+      this.#checkValidDependency({identifier: place.identifier, path: []})
    ) {
      currentScope.reassignments.add(place.identifier);
    }
@@ -664,10 +638,7 @@ enum HIRValue {
  Terminal,
 }

-export function handleInstruction(
-  instr: Instruction,
-  context: DependencyCollectionContext,
-): void {
+function handleInstruction(instr: Instruction, context: Context): void {
  const {id, value, lvalue} = instr;
  context.declare(lvalue.identifier, {
    id,
@@ -691,21 +662,21 @@ export function handleInstruction(
    });
  } else if (value.kind === 'DeclareLocal' || value.kind === 'DeclareContext') {
    /*
-     * Some variables may be declared and never initialized. We need to retain
-     * (and hoist) these declarations if they are included in a reactive scope.
-     * One approach is to simply add all `DeclareLocal`s as scope declarations.
-     *
-     * Context variables with hoisted declarations only become live after their
-     * first assignment. We only declare real DeclareLocal / DeclareContext
-     * instructions (not hoisted ones) to avoid generating dependencies on
-     * hoisted declarations.
+     * Some variables may be declared and never initialized. We need
+     * to retain (and hoist) these declarations if they are included
+     * in a reactive scope. One approach is to simply add all `DeclareLocal`s
+     * as scope declarations.
     */
-    if (convertHoistedLValueKind(value.lvalue.kind) === null) {
-      context.declare(value.lvalue.place.identifier, {
-        id,
-        scope: context.currentScope,
-      });
-    }
+
+    /*
+     * We add context variable declarations here, not at `StoreContext`, since
+     * context Store / Loads are modeled as reads and mutates to the underlying
+     * variable reference (instead of through intermediate / inlined temporaries)
+     */
+    context.declare(value.lvalue.place.identifier, {
+      id,
+      scope: context.currentScope,
+    });
  } else if (value.kind === 'Destructure') {
    context.visitOperand(value.value);
    for (const place of eachPatternOperand(value.lvalue.pattern)) {
@@ -717,26 +688,6 @@ export function handleInstruction(
        scope: context.currentScope,
      });
    }
-  } else if (value.kind === 'StoreContext') {
-    /**
-     * Some StoreContext variables have hoisted declarations. If we're storing
-     * to a context variable that hasn't yet been declared, the StoreContext is
-     * the declaration.
-     * (see corresponding logic in PruneHoistedContext)
-     */
-    if (
-      !context.hasDeclared(value.lvalue.place.identifier) ||
-      value.lvalue.kind !== InstructionKind.Reassign
-    ) {
-      context.declare(value.lvalue.place.identifier, {
-        id,
-        scope: context.currentScope,
-      });
-    }
-
-    for (const operand of eachInstructionValueOperand(value)) {
-      context.visitOperand(operand);
-    }
  } else {
    for (const operand of eachInstructionValueOperand(value)) {
      context.visitOperand(operand);
@@ -750,7 +701,7 @@ function collectDependencies(
  temporaries: ReadonlyMap<IdentifierId, ReactiveScopeDependency>,
  processedInstrsInOptional: ReadonlySet<Instruction | Terminal>,
 ): Map<ReactiveScope, Array<ReactiveScopeDependency>> {
-  const context = new DependencyCollectionContext(
+  const context = new Context(
    usedOutsideDeclaringScope,
    temporaries,
    processedInstrsInOptional,
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/PruneUnusedLabelsHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/PruneUnusedLabelsHIR.ts
@@ -1,10 +1,3 @@
-/**
- * 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 {BlockId, GotoVariant, HIRFunction} from './HIR';

--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/ScopeDependencyUtils.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/ScopeDependencyUtils.ts
@@ -1,285 +0,0 @@
-import {
-  Place,
-  ReactiveScopeDependency,
-  Identifier,
-  makeInstructionId,
-  InstructionKind,
-  GeneratedSource,
-  BlockId,
-  makeTemporaryIdentifier,
-  Effect,
-  GotoVariant,
-  HIR,
-} from './HIR';
-import {CompilerError} from '../CompilerError';
-import {Environment} from './Environment';
-import HIRBuilder from './HIRBuilder';
-import {lowerValueToTemporary} from './BuildHIR';
-
-type DependencyInstructions = {
-  place: Place;
-  value: HIR;
-  exitBlockId: BlockId;
-};
-
-export function buildDependencyInstructions(
-  dep: ReactiveScopeDependency,
-  env: Environment,
-): DependencyInstructions {
-  const builder = new HIRBuilder(env, {
-    entryBlockKind: 'value',
-  });
-  let dependencyValue: Identifier;
-  if (dep.path.every(path => !path.optional)) {
-    dependencyValue = writeNonOptionalDependency(dep, env, builder);
-  } else {
-    dependencyValue = writeOptionalDependency(dep, builder, null);
-  }
-
-  const exitBlockId = builder.terminate(
-    {
-      kind: 'unsupported',
-      loc: GeneratedSource,
-      id: makeInstructionId(0),
-    },
-    null,
-  );
-  return {
-    place: {
-      kind: 'Identifier',
-      identifier: dependencyValue,
-      effect: Effect.Freeze,
-      reactive: dep.reactive,
-      loc: GeneratedSource,
-    },
-    value: builder.build(),
-    exitBlockId,
-  };
-}
-
-/**
- * Write instructions for a simple dependency (without optional chains)
- */
-function writeNonOptionalDependency(
-  dep: ReactiveScopeDependency,
-  env: Environment,
-  builder: HIRBuilder,
-): Identifier {
-  const loc = dep.identifier.loc;
-  let curr: Identifier = makeTemporaryIdentifier(env.nextIdentifierId, loc);
-  builder.push({
-    lvalue: {
-      identifier: curr,
-      kind: 'Identifier',
-      effect: Effect.Mutate,
-      reactive: dep.reactive,
-      loc,
-    },
-    value: {
-      kind: 'LoadLocal',
-      place: {
-        identifier: dep.identifier,
-        kind: 'Identifier',
-        effect: Effect.Freeze,
-        reactive: dep.reactive,
-        loc,
-      },
-      loc,
-    },
-    id: makeInstructionId(1),
-    loc: loc,
-    effects: null,
-  });
-
-  /**
-   * Iteratively build up dependency instructions by reading from the last written
-   * instruction.
-   */
-  for (const path of dep.path) {
-    const next = makeTemporaryIdentifier(env.nextIdentifierId, loc);
-    builder.push({
-      lvalue: {
-        identifier: next,
-        kind: 'Identifier',
-        effect: Effect.Mutate,
-        reactive: dep.reactive,
-        loc,
-      },
-      value: {
-        kind: 'PropertyLoad',
-        object: {
-          identifier: curr,
-          kind: 'Identifier',
-          effect: Effect.Freeze,
-          reactive: dep.reactive,
-          loc,
-        },
-        property: path.property,
-        loc,
-      },
-      id: makeInstructionId(1),
-      loc: loc,
-      effects: null,
-    });
-    curr = next;
-  }
-  return curr;
-}
-
-/**
- * Write a dependency into optional blocks.
- *
- * e.g. `a.b?.c.d` is written to an optional block that tests `a.b` and
- * conditionally evaluates `c.d`.
- */
-function writeOptionalDependency(
-  dep: ReactiveScopeDependency,
-  builder: HIRBuilder,
-  parentAlternate: BlockId | null,
-): Identifier {
-  const env = builder.environment;
-  /**
-   * Reserve an identifier which will be used to store the result of this
-   * dependency.
-   */
-  const dependencyValue: Place = {
-    kind: 'Identifier',
-    identifier: makeTemporaryIdentifier(env.nextIdentifierId, GeneratedSource),
-    effect: Effect.Mutate,
-    reactive: dep.reactive,
-    loc: GeneratedSource,
-  };
-
-  /**
-   * Reserve a block which is the fallthrough (and transitive successor) of this
-   * optional chain.
-   */
-  const continuationBlock = builder.reserve(builder.currentBlockKind());
-  let alternate;
-  if (parentAlternate != null) {
-    alternate = parentAlternate;
-  } else {
-    /**
-     * If an outermost alternate block has not been reserved, write one
-     *
-     * $N = Primitive undefined
-     * $M = StoreLocal $OptionalResult = $N
-     * goto fallthrough
-     */
-    alternate = builder.enter('value', () => {
-      const temp = lowerValueToTemporary(builder, {
-        kind: 'Primitive',
-        value: undefined,
-        loc: GeneratedSource,
-      });
-      lowerValueToTemporary(builder, {
-        kind: 'StoreLocal',
-        lvalue: {kind: InstructionKind.Const, place: {...dependencyValue}},
-        value: {...temp},
-        type: null,
-        loc: GeneratedSource,
-      });
-      return {
-        kind: 'goto',
-        variant: GotoVariant.Break,
-        block: continuationBlock.id,
-        id: makeInstructionId(0),
-        loc: GeneratedSource,
-      };
-    });
-  }
-
-  // Reserve the consequent block, which is the successor of the test block
-  const consequent = builder.reserve('value');
-
-  let testIdentifier: Identifier | null = null;
-  const testBlock = builder.enter('value', () => {
-    const testDependency = {
-      ...dep,
-      path: dep.path.slice(0, dep.path.length - 1),
-    };
-    const firstOptional = dep.path.findIndex(path => path.optional);
-    CompilerError.invariant(firstOptional !== -1, {
-      reason:
-        '[ScopeDependencyUtils] Internal invariant broken: expected optional path',
-      loc: dep.identifier.loc,
-      description: null,
-      suggestions: null,
-    });
-    if (firstOptional === dep.path.length - 1) {
-      // Base case: the test block is simple
-      testIdentifier = writeNonOptionalDependency(testDependency, env, builder);
-    } else {
-      // Otherwise, the test block is a nested optional chain
-      testIdentifier = writeOptionalDependency(
-        testDependency,
-        builder,
-        alternate,
-      );
-    }
-
-    return {
-      kind: 'branch',
-      test: {
-        identifier: testIdentifier,
-        effect: Effect.Freeze,
-        kind: 'Identifier',
-        loc: GeneratedSource,
-        reactive: dep.reactive,
-      },
-      consequent: consequent.id,
-      alternate,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-      fallthrough: continuationBlock.id,
-    };
-  });
-
-  builder.enterReserved(consequent, () => {
-    CompilerError.invariant(testIdentifier !== null, {
-      reason: 'Satisfy type checker',
-      description: null,
-      loc: null,
-      suggestions: null,
-    });
-
-    lowerValueToTemporary(builder, {
-      kind: 'StoreLocal',
-      lvalue: {kind: InstructionKind.Const, place: {...dependencyValue}},
-      value: lowerValueToTemporary(builder, {
-        kind: 'PropertyLoad',
-        object: {
-          identifier: testIdentifier,
-          kind: 'Identifier',
-          effect: Effect.Freeze,
-          reactive: dep.reactive,
-          loc: GeneratedSource,
-        },
-        property: dep.path.at(-1)!.property,
-        loc: GeneratedSource,
-      }),
-      type: null,
-      loc: GeneratedSource,
-    });
-    return {
-      kind: 'goto',
-      variant: GotoVariant.Break,
-      block: continuationBlock.id,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-    };
-  });
-  builder.terminateWithContinuation(
-    {
-      kind: 'optional',
-      optional: dep.path.at(-1)!.optional,
-      test: testBlock,
-      fallthrough: continuationBlock.id,
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-    },
-    continuationBlock,
-  );
-
-  return dependencyValue.identifier;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/TypeSchema.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/TypeSchema.ts
@@ -8,12 +8,7 @@
 import {isValidIdentifier} from '@babel/types';
 import {z} from 'zod';
 import {Effect, ValueKind} from '..';
-import {
-  EffectSchema,
-  ValueKindSchema,
-  ValueReason,
-  ValueReasonSchema,
-} from './HIR';
+import {EffectSchema, ValueKindSchema} from './HIR';

 export type ObjectPropertiesConfig = {[key: string]: TypeConfig};
 export const ObjectPropertiesSchema: z.ZodType<ObjectPropertiesConfig> = z
@@ -36,209 +31,6 @@ export const ObjectTypeSchema: z.ZodType<ObjectTypeConfig> = z.object({
  properties: ObjectPropertiesSchema.nullable(),
 });

-export const LifetimeIdSchema = z.string().refine(id => id.startsWith('@'), {
-  message: "Placeholder names must start with '@'",
-});
-
-export type FreezeEffectConfig = {
-  kind: 'Freeze';
-  value: string;
-  reason: ValueReason;
-};
-
-export const FreezeEffectSchema: z.ZodType<FreezeEffectConfig> = z.object({
-  kind: z.literal('Freeze'),
-  value: LifetimeIdSchema,
-  reason: ValueReasonSchema,
-});
-
-export type MutateEffectConfig = {
-  kind: 'Mutate';
-  value: string;
-};
-
-export const MutateEffectSchema: z.ZodType<MutateEffectConfig> = z.object({
-  kind: z.literal('Mutate'),
-  value: LifetimeIdSchema,
-});
-
-export type MutateTransitiveConditionallyConfig = {
-  kind: 'MutateTransitiveConditionally';
-  value: string;
-};
-
-export const MutateTransitiveConditionallySchema: z.ZodType<MutateTransitiveConditionallyConfig> =
-  z.object({
-    kind: z.literal('MutateTransitiveConditionally'),
-    value: LifetimeIdSchema,
-  });
-
-export type CreateEffectConfig = {
-  kind: 'Create';
-  into: string;
-  value: ValueKind;
-  reason: ValueReason;
-};
-
-export const CreateEffectSchema: z.ZodType<CreateEffectConfig> = z.object({
-  kind: z.literal('Create'),
-  into: LifetimeIdSchema,
-  value: ValueKindSchema,
-  reason: ValueReasonSchema,
-});
-
-export type AssignEffectConfig = {
-  kind: 'Assign';
-  from: string;
-  into: string;
-};
-
-export const AssignEffectSchema: z.ZodType<AssignEffectConfig> = z.object({
-  kind: z.literal('Assign'),
-  from: LifetimeIdSchema,
-  into: LifetimeIdSchema,
-});
-
-export type AliasEffectConfig = {
-  kind: 'Alias';
-  from: string;
-  into: string;
-};
-
-export const AliasEffectSchema: z.ZodType<AliasEffectConfig> = z.object({
-  kind: z.literal('Alias'),
-  from: LifetimeIdSchema,
-  into: LifetimeIdSchema,
-});
-
-export type ImmutableCaptureEffectConfig = {
-  kind: 'ImmutableCapture';
-  from: string;
-  into: string;
-};
-
-export const ImmutableCaptureEffectSchema: z.ZodType<ImmutableCaptureEffectConfig> =
-  z.object({
-    kind: z.literal('ImmutableCapture'),
-    from: LifetimeIdSchema,
-    into: LifetimeIdSchema,
-  });
-
-export type CaptureEffectConfig = {
-  kind: 'Capture';
-  from: string;
-  into: string;
-};
-
-export const CaptureEffectSchema: z.ZodType<CaptureEffectConfig> = z.object({
-  kind: z.literal('Capture'),
-  from: LifetimeIdSchema,
-  into: LifetimeIdSchema,
-});
-
-export type CreateFromEffectConfig = {
-  kind: 'CreateFrom';
-  from: string;
-  into: string;
-};
-
-export const CreateFromEffectSchema: z.ZodType<CreateFromEffectConfig> =
-  z.object({
-    kind: z.literal('CreateFrom'),
-    from: LifetimeIdSchema,
-    into: LifetimeIdSchema,
-  });
-
-export type ApplyArgConfig =
-  | string
-  | {kind: 'Spread'; place: string}
-  | {kind: 'Hole'};
-
-export const ApplyArgSchema: z.ZodType<ApplyArgConfig> = z.union([
-  LifetimeIdSchema,
-  z.object({
-    kind: z.literal('Spread'),
-    place: LifetimeIdSchema,
-  }),
-  z.object({
-    kind: z.literal('Hole'),
-  }),
-]);
-
-export type ApplyEffectConfig = {
-  kind: 'Apply';
-  receiver: string;
-  function: string;
-  mutatesFunction: boolean;
-  args: Array<ApplyArgConfig>;
-  into: string;
-};
-
-export const ApplyEffectSchema: z.ZodType<ApplyEffectConfig> = z.object({
-  kind: z.literal('Apply'),
-  receiver: LifetimeIdSchema,
-  function: LifetimeIdSchema,
-  mutatesFunction: z.boolean(),
-  args: z.array(ApplyArgSchema),
-  into: LifetimeIdSchema,
-});
-
-export type ImpureEffectConfig = {
-  kind: 'Impure';
-  place: string;
-};
-
-export const ImpureEffectSchema: z.ZodType<ImpureEffectConfig> = z.object({
-  kind: z.literal('Impure'),
-  place: LifetimeIdSchema,
-});
-
-export type AliasingEffectConfig =
-  | FreezeEffectConfig
-  | CreateEffectConfig
-  | CreateFromEffectConfig
-  | AssignEffectConfig
-  | AliasEffectConfig
-  | CaptureEffectConfig
-  | ImmutableCaptureEffectConfig
-  | ImpureEffectConfig
-  | MutateEffectConfig
-  | MutateTransitiveConditionallyConfig
-  | ApplyEffectConfig;
-
-export const AliasingEffectSchema: z.ZodType<AliasingEffectConfig> = z.union([
-  FreezeEffectSchema,
-  CreateEffectSchema,
-  CreateFromEffectSchema,
-  AssignEffectSchema,
-  AliasEffectSchema,
-  CaptureEffectSchema,
-  ImmutableCaptureEffectSchema,
-  ImpureEffectSchema,
-  MutateEffectSchema,
-  MutateTransitiveConditionallySchema,
-  ApplyEffectSchema,
-]);
-
-export type AliasingSignatureConfig = {
-  receiver: string;
-  params: Array<string>;
-  rest: string | null;
-  returns: string;
-  effects: Array<AliasingEffectConfig>;
-  temporaries: Array<string>;
-};
-
-export const AliasingSignatureSchema: z.ZodType<AliasingSignatureConfig> =
-  z.object({
-    receiver: LifetimeIdSchema,
-    params: z.array(LifetimeIdSchema),
-    rest: LifetimeIdSchema.nullable(),
-    returns: LifetimeIdSchema,
-    effects: z.array(AliasingEffectSchema),
-    temporaries: z.array(LifetimeIdSchema),
-  });
-
 export type FunctionTypeConfig = {
  kind: 'function';
  positionalParams: Array<Effect>;
@@ -250,7 +42,6 @@ export type FunctionTypeConfig = {
  mutableOnlyIfOperandsAreMutable?: boolean | null | undefined;
  impure?: boolean | null | undefined;
  canonicalName?: string | null | undefined;
-  aliasing?: AliasingSignatureConfig | null | undefined;
 };
 export const FunctionTypeSchema: z.ZodType<FunctionTypeConfig> = z.object({
  kind: z.literal('function'),
@@ -263,7 +54,6 @@ export const FunctionTypeSchema: z.ZodType<FunctionTypeConfig> = z.object({
  mutableOnlyIfOperandsAreMutable: z.boolean().nullable().optional(),
  impure: z.boolean().nullable().optional(),
  canonicalName: z.string().nullable().optional(),
-  aliasing: AliasingSignatureSchema.nullable().optional(),
 });

 export type HookTypeConfig = {
@@ -273,7 +63,6 @@ export type HookTypeConfig = {
  returnType: TypeConfig;
  returnValueKind?: ValueKind | null | undefined;
  noAlias?: boolean | null | undefined;
-  aliasing?: AliasingSignatureConfig | null | undefined;
 };
 export const HookTypeSchema: z.ZodType<HookTypeConfig> = z.object({
  kind: z.literal('hook'),
@@ -282,7 +71,6 @@ export const HookTypeSchema: z.ZodType<HookTypeConfig> = z.object({
  returnType: z.lazy(() => TypeSchema),
  returnValueKind: ValueKindSchema.nullable().optional(),
  noAlias: z.boolean().nullable().optional(),
-  aliasing: AliasingSignatureSchema.nullable().optional(),
 });

 export type BuiltInTypeConfig =
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/Types.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/Types.ts
@@ -38,7 +38,6 @@ export type FunctionType = {
  kind: 'Function';
  shapeId: string | null;
  return: Type;
-  isConstructor: boolean;
 };

 export type ObjectType = {
@@ -112,7 +111,6 @@ export function duplicateType(type: Type): Type {
        kind: 'Function',
        return: duplicateType(type.return),
        shapeId: type.shapeId,
-        isConstructor: type.isConstructor,
      };
    }
    case 'Object': {
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/index.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/index.ts
@@ -17,6 +17,7 @@ export {buildReactiveScopeTerminalsHIR} from './BuildReactiveScopeTerminalsHIR';
 export {computeDominatorTree, computePostDominatorTree} from './Dominator';
 export {
  Environment,
+  parseConfigPragmaForTests,
  validateEnvironmentConfig,
  type EnvironmentConfig,
  type ExternalFunction,
@@ -31,5 +32,5 @@ export {
 } from './HIRBuilder';
 export {mergeConsecutiveBlocks} from './MergeConsecutiveBlocks';
 export {mergeOverlappingReactiveScopesHIR} from './MergeOverlappingReactiveScopesHIR';
-export {printFunction, printHIR, printFunctionWithOutlined} from './PrintHIR';
+export {printFunction, printHIR} from './PrintHIR';
 export {pruneUnusedLabelsHIR} from './PruneUnusedLabelsHIR';
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/visitors.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/visitors.ts
@@ -345,51 +345,6 @@ export function* eachPatternOperand(pattern: Pattern): Iterable<Place> {
  }
 }

-export function* eachPatternItem(
-  pattern: Pattern,
-): Iterable<Place | SpreadPattern> {
-  switch (pattern.kind) {
-    case 'ArrayPattern': {
-      for (const item of pattern.items) {
-        if (item.kind === 'Identifier') {
-          yield item;
-        } else if (item.kind === 'Spread') {
-          yield item;
-        } else if (item.kind === 'Hole') {
-          continue;
-        } else {
-          assertExhaustive(
-            item,
-            `Unexpected item kind \`${(item as any).kind}\``,
-          );
-        }
-      }
-      break;
-    }
-    case 'ObjectPattern': {
-      for (const property of pattern.properties) {
-        if (property.kind === 'ObjectProperty') {
-          yield property.place;
-        } else if (property.kind === 'Spread') {
-          yield property;
-        } else {
-          assertExhaustive(
-            property,
-            `Unexpected item kind \`${(property as any).kind}\``,
-          );
-        }
-      }
-      break;
-    }
-    default: {
-      assertExhaustive(
-        pattern,
-        `Unexpected pattern kind \`${(pattern as any).kind}\``,
-      );
-    }
-  }
-}
-
 export function mapInstructionLValues(
  instr: Instruction,
  fn: (place: Place) => Place,
@@ -777,11 +732,9 @@ export function mapTerminalSuccessors(
    case 'return': {
      return {
        kind: 'return',
-        returnVariant: terminal.returnVariant,
        loc: terminal.loc,
        value: terminal.value,
        id: makeInstructionId(0),
-        effects: terminal.effects,
      };
    }
    case 'throw': {
@@ -889,7 +842,6 @@ export function mapTerminalSuccessors(
        handler,
        id: makeInstructionId(0),
        loc: terminal.loc,
-        effects: terminal.effects,
      };
    }
    case 'try': {
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/AliasingEffects.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/AliasingEffects.ts
@@ -1,264 +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 {CompilerDiagnostic} from '../CompilerError';
-import {
-  FunctionExpression,
-  GeneratedSource,
-  Hole,
-  IdentifierId,
-  ObjectMethod,
-  Place,
-  SourceLocation,
-  SpreadPattern,
-  ValueKind,
-  ValueReason,
-} from '../HIR';
-import {FunctionSignature} from '../HIR/ObjectShape';
-import {printSourceLocation} from '../HIR/PrintHIR';
-
-/**
- * `AliasingEffect` describes a set of "effects" that an instruction/terminal has on one or
- * more values in a program. These effects include mutation of values, freezing values,
- * tracking data flow between values, and other specialized cases.
- */
-export type AliasingEffect =
-  /**
-   * Marks the given value and its direct aliases as frozen.
-   *
-   * Captured values are *not* considered frozen, because we cannot be sure that a previously
-   * captured value will still be captured at the point of the freeze.
-   *
-   * For example:
-   * const x = {};
-   * const y = [x];
-   * y.pop(); // y dosn't contain x anymore!
-   * freeze(y);
-   * mutate(x); // safe to mutate!
-   *
-   * The exception to this is FunctionExpressions - since it is impossible to change which
-   * value a function closes over[1] we can transitively freeze functions and their captures.
-   *
-   * [1] Except for `let` values that are reassigned and closed over by a function, but we
-   * handle this explicitly with StoreContext/LoadContext.
-   */
-  | {kind: 'Freeze'; value: Place; reason: ValueReason}
-  /**
-   * Mutate the value and any direct aliases (not captures). Errors if the value is not mutable.
-   */
-  | {kind: 'Mutate'; value: Place; reason?: MutationReason | null}
-  /**
-   * Mutate the value and any direct aliases (not captures), but only if the value is known mutable.
-   * This should be rare.
-   *
-   * TODO: this is only used for IteratorNext, but even then MutateTransitiveConditionally is more
-   * correct for iterators of unknown types.
-   */
-  | {kind: 'MutateConditionally'; value: Place}
-  /**
-   * Mutate the value, any direct aliases, and any transitive captures. Errors if the value is not mutable.
-   */
-  | {kind: 'MutateTransitive'; value: Place}
-  /**
-   * Mutates any of the value, its direct aliases, and its transitive captures that are mutable.
-   */
-  | {kind: 'MutateTransitiveConditionally'; value: Place}
-  /**
-   * Records information flow from `from` to `into` in cases where local mutation of the destination
-   * will *not* mutate the source:
-   *
-   * - Capture a -> b and Mutate(b) X=> (does not imply) Mutate(a)
-   * - Capture a -> b and MutateTransitive(b) => (does imply) Mutate(a)
-   *
-   * Example: `array.push(item)`. Information from item is captured into array, but there is not a
-   * direct aliasing, and local mutations of array will not modify item.
-   */
-  | {kind: 'Capture'; from: Place; into: Place}
-  /**
-   * Records information flow from `from` to `into` in cases where local mutation of the destination
-   * *will* mutate the source:
-   *
-   * - Alias a -> b and Mutate(b) => (does imply) Mutate(a)
-   * - Alias a -> b and MutateTransitive(b) => (does imply) Mutate(a)
-   *
-   * Example: `c = identity(a)`. We don't know what `identity()` returns so we can't use Assign.
-   * But we have to assume that it _could_ be returning its input, such that a local mutation of
-   * c could be mutating a.
-   */
-  | {kind: 'Alias'; from: Place; into: Place}
-
-  /**
-   * Indicates the potential for information flow from `from` to `into`. This is used for a specific
-   * case: functions with unknown signatures. If the compiler sees a call such as `foo(x)`, it has to
-   * consider several possibilities (which may depend on the arguments):
-   * - foo(x) returns a new mutable value that does not capture any information from x.
-   * - foo(x) returns a new mutable value that *does* capture information from x.
-   * - foo(x) returns x itself, ie foo is the identity function
-   *
-   * The same is true of functions that take multiple arguments: `cond(a, b, c)` could conditionally
-   * return b or c depending on the value of a.
-   *
-   * To represent this case, MaybeAlias represents the fact that an aliasing relationship could exist.
-   * Any mutations that flow through this relationship automatically become conditional.
-   */
-  | {kind: 'MaybeAlias'; from: Place; into: Place}
-
-  /**
-   * Records direct assignment: `into = from`.
-   */
-  | {kind: 'Assign'; from: Place; into: Place}
-  /**
-   * Creates a value of the given type at the given place
-   */
-  | {kind: 'Create'; into: Place; value: ValueKind; reason: ValueReason}
-  /**
-   * Creates a new value with the same kind as the starting value.
-   */
-  | {kind: 'CreateFrom'; from: Place; into: Place}
-  /**
-   * Immutable data flow, used for escape analysis. Does not influence mutable range analysis:
-   */
-  | {kind: 'ImmutableCapture'; from: Place; into: Place}
-  /**
-   * Calls the function at the given place with the given arguments either captured or aliased,
-   * and captures/aliases the result into the given place.
-   */
-  | {
-      kind: 'Apply';
-      receiver: Place;
-      function: Place;
-      mutatesFunction: boolean;
-      args: Array<Place | SpreadPattern | Hole>;
-      into: Place;
-      signature: FunctionSignature | null;
-      loc: SourceLocation;
-    }
-  /**
-   * Constructs a function value with the given captures. The mutability of the function
-   * will be determined by the mutability of the capture values when evaluated.
-   */
-  | {
-      kind: 'CreateFunction';
-      captures: Array<Place>;
-      function: FunctionExpression | ObjectMethod;
-      into: Place;
-    }
-  /**
-   * Mutation of a value known to be immutable
-   */
-  | {kind: 'MutateFrozen'; place: Place; error: CompilerDiagnostic}
-  /**
-   * Mutation of a global
-   */
-  | {
-      kind: 'MutateGlobal';
-      place: Place;
-      error: CompilerDiagnostic;
-    }
-  /**
-   * Indicates a side-effect that is not safe during render
-   */
-  | {kind: 'Impure'; place: Place; error: CompilerDiagnostic}
-  /**
-   * Indicates that a given place is accessed during render. Used to distingush
-   * hook arguments that are known to be called immediately vs those used for
-   * event handlers/effects, and for JSX values known to be called during render
-   * (tags, children) vs those that may be events/effect (other props).
-   */
-  | {
-      kind: 'Render';
-      place: Place;
-    };
-
-export type MutationReason = {kind: 'AssignCurrentProperty'};
-
-export function hashEffect(effect: AliasingEffect): string {
-  switch (effect.kind) {
-    case 'Apply': {
-      return [
-        effect.kind,
-        effect.receiver.identifier.id,
-        effect.function.identifier.id,
-        effect.mutatesFunction,
-        effect.args
-          .map(a => {
-            if (a.kind === 'Hole') {
-              return '';
-            } else if (a.kind === 'Identifier') {
-              return a.identifier.id;
-            } else {
-              return `...${a.place.identifier.id}`;
-            }
-          })
-          .join(','),
-        effect.into.identifier.id,
-      ].join(':');
-    }
-    case 'CreateFrom':
-    case 'ImmutableCapture':
-    case 'Assign':
-    case 'Alias':
-    case 'Capture':
-    case 'MaybeAlias': {
-      return [
-        effect.kind,
-        effect.from.identifier.id,
-        effect.into.identifier.id,
-      ].join(':');
-    }
-    case 'Create': {
-      return [
-        effect.kind,
-        effect.into.identifier.id,
-        effect.value,
-        effect.reason,
-      ].join(':');
-    }
-    case 'Freeze': {
-      return [effect.kind, effect.value.identifier.id, effect.reason].join(':');
-    }
-    case 'Impure':
-    case 'Render': {
-      return [effect.kind, effect.place.identifier.id].join(':');
-    }
-    case 'MutateFrozen':
-    case 'MutateGlobal': {
-      return [
-        effect.kind,
-        effect.place.identifier.id,
-        effect.error.severity,
-        effect.error.reason,
-        effect.error.description,
-        printSourceLocation(effect.error.primaryLocation() ?? GeneratedSource),
-      ].join(':');
-    }
-    case 'Mutate':
-    case 'MutateConditionally':
-    case 'MutateTransitive':
-    case 'MutateTransitiveConditionally': {
-      return [effect.kind, effect.value.identifier.id].join(':');
-    }
-    case 'CreateFunction': {
-      return [
-        effect.kind,
-        effect.into.identifier.id,
-        // return places are a unique way to identify functions themselves
-        effect.function.loweredFunc.func.returns.identifier.id,
-        effect.captures.map(p => p.identifier.id).join(','),
-      ].join(':');
-    }
-  }
-}
-
-export type AliasingSignature = {
-  receiver: IdentifierId;
-  params: Array<IdentifierId>;
-  rest: IdentifierId | null;
-  returns: IdentifierId;
-  effects: Array<AliasingEffect>;
-  temporaries: Array<Place>;
-};
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/AnalyseFunctions.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/AnalyseFunctions.ts
@@ -6,13 +6,19 @@
 */

 import {CompilerError} from '../CompilerError';
-import {Effect, HIRFunction, IdentifierId, makeInstructionId} from '../HIR';
+import {
+  Effect,
+  HIRFunction,
+  Identifier,
+  LoweredFunction,
+  isRefOrRefValue,
+  makeInstructionId,
+} from '../HIR';
 import {deadCodeElimination} from '../Optimization';
 import {inferReactiveScopeVariables} from '../ReactiveScopes';
 import {rewriteInstructionKindsBasedOnReassignment} from '../SSA';
-import {assertExhaustive} from '../Utils/utils';
-import {inferMutationAliasingEffects} from './InferMutationAliasingEffects';
-import {inferMutationAliasingRanges} from './InferMutationAliasingRanges';
+import {inferMutableRanges} from './InferMutableRanges';
+import inferReferenceEffects from './InferReferenceEffects';

 export default function analyseFunctions(func: HIRFunction): void {
  for (const [_, block] of func.body.blocks) {
@@ -20,22 +26,15 @@ export default function analyseFunctions(func: HIRFunction): void {
      switch (instr.value.kind) {
        case 'ObjectMethod':
        case 'FunctionExpression': {
-          lowerWithMutationAliasing(instr.value.loweredFunc.func);
+          lower(instr.value.loweredFunc.func);
+          infer(instr.value.loweredFunc);

          /**
           * Reset mutable range for outer inferReferenceEffects
           */
          for (const operand of instr.value.loweredFunc.func.context) {
-            /**
-             * NOTE: inferReactiveScopeVariables makes identifiers in the scope
-             * point to the *same* mutableRange instance. Resetting start/end
-             * here is insufficient, because a later mutation of the range
-             * for any one identifier could affect the range for other identifiers.
-             */
-            operand.identifier.mutableRange = {
-              start: makeInstructionId(0),
-              end: makeInstructionId(0),
-            };
+            operand.identifier.mutableRange.start = makeInstructionId(0);
+            operand.identifier.mutableRange.end = makeInstructionId(0);
            operand.identifier.scope = null;
          }
          break;
@@ -45,83 +44,57 @@ export default function analyseFunctions(func: HIRFunction): void {
  }
 }

-function lowerWithMutationAliasing(fn: HIRFunction): void {
-  /**
-   * Phase 1: similar to lower(), but using the new mutation/aliasing inference
-   */
-  analyseFunctions(fn);
-  inferMutationAliasingEffects(fn, {isFunctionExpression: true});
-  deadCodeElimination(fn);
-  const functionEffects = inferMutationAliasingRanges(fn, {
-    isFunctionExpression: true,
-  }).unwrap();
-  rewriteInstructionKindsBasedOnReassignment(fn);
-  inferReactiveScopeVariables(fn);
-  fn.aliasingEffects = functionEffects;
+function lower(func: HIRFunction): void {
+  analyseFunctions(func);
+  inferReferenceEffects(func, {isFunctionExpression: true});
+  deadCodeElimination(func);
+  inferMutableRanges(func);
+  rewriteInstructionKindsBasedOnReassignment(func);
+  inferReactiveScopeVariables(func);
+  func.env.logger?.debugLogIRs?.({
+    kind: 'hir',
+    name: 'AnalyseFunction (inner)',
+    value: func,
+  });
+}

-  /**
-   * Phase 2: populate the Effect of each context variable to use in inferring
-   * the outer function. For example, InferMutationAliasingEffects uses context variable
-   * effects to decide if the function may be mutable or not.
-   */
-  const capturedOrMutated = new Set<IdentifierId>();
-  for (const effect of functionEffects) {
-    switch (effect.kind) {
-      case 'Assign':
-      case 'Alias':
-      case 'Capture':
-      case 'CreateFrom':
-      case 'MaybeAlias': {
-        capturedOrMutated.add(effect.from.identifier.id);
-        break;
-      }
-      case 'Apply': {
-        CompilerError.invariant(false, {
-          reason: `[AnalyzeFunctions] Expected Apply effects to be replaced with more precise effects`,
-          loc: effect.function.loc,
-        });
-      }
-      case 'Mutate':
-      case 'MutateConditionally':
-      case 'MutateTransitive':
-      case 'MutateTransitiveConditionally': {
-        capturedOrMutated.add(effect.value.identifier.id);
-        break;
-      }
-      case 'Impure':
-      case 'Render':
-      case 'MutateFrozen':
-      case 'MutateGlobal':
-      case 'CreateFunction':
-      case 'Create':
-      case 'Freeze':
-      case 'ImmutableCapture': {
-        // no-op
-        break;
-      }
-      default: {
-        assertExhaustive(
-          effect,
-          `Unexpected effect kind ${(effect as any).kind}`,
-        );
-      }
-    }
-  }
-
-  for (const operand of fn.context) {
-    if (
-      capturedOrMutated.has(operand.identifier.id) ||
-      operand.effect === Effect.Capture
-    ) {
+function infer(loweredFunc: LoweredFunction): void {
+  for (const operand of loweredFunc.func.context) {
+    const identifier = operand.identifier;
+    CompilerError.invariant(operand.effect === Effect.Unknown, {
+      reason:
+        '[AnalyseFunctions] Expected Function context effects to not have been set',
+      loc: operand.loc,
+    });
+    if (isRefOrRefValue(identifier)) {
+      /*
+       * TODO: this is a hack to ensure we treat functions which reference refs
+       * as having a capture and therefore being considered mutable. this ensures
+       * the function gets a mutable range which accounts for anywhere that it
+       * could be called, and allows us to help ensure it isn't called during
+       * render
+       */
+      operand.effect = Effect.Capture;
+    } else if (isMutatedOrReassigned(identifier)) {
+      /**
+       * Reflects direct reassignments, PropertyStores, and ConditionallyMutate
+       * (directly or through maybe-aliases)
+       */
      operand.effect = Effect.Capture;
    } else {
      operand.effect = Effect.Read;
    }
  }
-
-  fn.env.logger?.debugLogIRs?.({
-    kind: 'hir',
-    name: 'AnalyseFunction (inner)',
-    value: fn,
-  });
+}
+
+function isMutatedOrReassigned(id: Identifier): boolean {
+  /*
+   * This check checks for mutation and reassingnment, so the usual check for
+   * mutation (ie, `mutableRange.end - mutableRange.start > 1`) isn't quite
+   * enough.
+   *
+   * We need to track re-assignments in context refs as we need to reflect the
+   * re-assignment back to the captured refs.
+   */
+  return id.mutableRange.end > id.mutableRange.start;
 }
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts
@@ -5,13 +5,7 @@
 * LICENSE file in the root directory of this source tree.
 */

-import {
-  CompilerDiagnostic,
-  CompilerError,
-  ErrorSeverity,
-  SourceLocation,
-} from '..';
-import {ErrorCategory} from '../CompilerError';
+import {CompilerError, SourceLocation} from '..';
 import {
  CallExpression,
  Effect,
@@ -36,7 +30,6 @@ import {
  makeInstructionId,
 } from '../HIR';
 import {createTemporaryPlace, markInstructionIds} from '../HIR/HIRBuilder';
-import {Result} from '../Utils/Result';

 type ManualMemoCallee = {
  kind: 'useMemo' | 'useCallback';
@@ -204,7 +197,6 @@ function makeManualMemoizationMarkers(
        deps: depsList,
        loc: fnExpr.loc,
      },
-      effects: null,
      loc: fnExpr.loc,
    },
    {
@@ -216,7 +208,6 @@ function makeManualMemoizationMarkers(
        decl: {...memoDecl},
        loc: fnExpr.loc,
      },
-      effects: null,
      loc: fnExpr.loc,
    },
  ];
@@ -290,45 +281,26 @@ function extractManualMemoizationArgs(
  instr: TInstruction<CallExpression> | TInstruction<MethodCall>,
  kind: 'useCallback' | 'useMemo',
  sidemap: IdentifierSidemap,
-  errors: CompilerError,
 ): {
-  fnPlace: Place | null;
+  fnPlace: Place;
  depsList: Array<ManualMemoDependency> | null;
 } {
  const [fnPlace, depsListPlace] = instr.value.args as Array<
    Place | SpreadPattern | undefined
  >;
  if (fnPlace == null) {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        category: ErrorCategory.UseMemo,
-        severity: ErrorSeverity.InvalidReact,
-        reason: `Expected a callback function to be passed to ${kind}`,
-        description: `Expected a callback function to be passed to ${kind}`,
-        suggestions: null,
-      }).withDetail({
-        kind: 'error',
-        loc: instr.value.loc,
-        message: `Expected a callback function to be passed to ${kind}`,
-      }),
-    );
-    return {fnPlace: null, depsList: null};
+    CompilerError.throwInvalidReact({
+      reason: `Expected a callback function to be passed to ${kind}`,
+      loc: instr.value.loc,
+      suggestions: null,
+    });
  }
  if (fnPlace.kind === 'Spread' || depsListPlace?.kind === 'Spread') {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        category: ErrorCategory.UseMemo,
-        severity: ErrorSeverity.InvalidReact,
-        reason: `Unexpected spread argument to ${kind}`,
-        description: `Unexpected spread argument to ${kind}`,
-        suggestions: null,
-      }).withDetail({
-        kind: 'error',
-        loc: instr.value.loc,
-        message: `Unexpected spread argument to ${kind}`,
-      }),
-    );
-    return {fnPlace: null, depsList: null};
+    CompilerError.throwInvalidReact({
+      reason: `Unexpected spread argument to ${kind}`,
+      loc: instr.value.loc,
+      suggestions: null,
+    });
  }
  let depsList: Array<ManualMemoDependency> | null = null;
  if (depsListPlace != null) {
@@ -336,42 +308,23 @@ function extractManualMemoizationArgs(
      depsListPlace.identifier.id,
    );
    if (maybeDepsList == null) {
-      errors.pushDiagnostic(
-        CompilerDiagnostic.create({
-          category: ErrorCategory.UseMemo,
-          severity: ErrorSeverity.InvalidReact,
-          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,
-        }).withDetail({
-          kind: 'error',
-          loc: depsListPlace.loc,
-          message: `Expected the dependency list for ${kind} to be an array literal`,
-        }),
-      );
-      return {fnPlace, depsList: null};
+      CompilerError.throwInvalidReact({
+        reason: `Expected the dependency list for ${kind} to be an array literal`,
+        suggestions: null,
+        loc: depsListPlace.loc,
+      });
    }
-    depsList = [];
-    for (const dep of maybeDepsList) {
+    depsList = maybeDepsList.map(dep => {
      const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
      if (maybeDep == null) {
-        errors.pushDiagnostic(
-          CompilerDiagnostic.create({
-            category: ErrorCategory.UseMemo,
-            severity: ErrorSeverity.InvalidReact,
-            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,
-          }).withDetail({
-            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);
+        CompilerError.throwInvalidReact({
+          reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+          suggestions: null,
+          loc: dep.loc,
+        });
      }
-    }
+      return maybeDep;
+    });
  }
  return {
    fnPlace,
@@ -386,14 +339,8 @@ function extractManualMemoizationArgs(
 * rely on type inference to find useMemo/useCallback invocations, and instead does basic tracking
 * of globals and property loads to find both direct calls as well as usage via the React namespace,
 * eg `React.useMemo()`.
- *
- * This pass also validates that useMemo callbacks return a value (not void), ensuring that useMemo
- * is only used for memoizing values and not for running arbitrary side effects.
 */
-export function dropManualMemoization(
-  func: HIRFunction,
-): Result<void, CompilerError> {
-  const errors = new CompilerError();
+export function dropManualMemoization(func: HIRFunction): void {
  const isValidationEnabled =
    func.env.config.validatePreserveExistingMemoizationGuarantees ||
    func.env.config.validateNoSetStateInRender ||
@@ -440,48 +387,7 @@ export function dropManualMemoization(
            instr as TInstruction<CallExpression> | TInstruction<MethodCall>,
            manualMemo.kind,
            sidemap,
-            errors,
          );
-
-          if (fnPlace == null) {
-            continue;
-          }
-
-          /**
-           * Bailout on void return useMemos. This is an anti-pattern where code might be using
-           * useMemo like useEffect: running arbirtary side-effects synced to changes in specific
-           * values.
-           */
-          if (
-            func.env.config.validateNoVoidUseMemo &&
-            manualMemo.kind === 'useMemo'
-          ) {
-            const funcToCheck = sidemap.functions.get(
-              fnPlace.identifier.id,
-            )?.value;
-            if (funcToCheck !== undefined && funcToCheck.loweredFunc.func) {
-              if (!hasNonVoidReturn(funcToCheck.loweredFunc.func)) {
-                errors.pushDiagnostic(
-                  CompilerDiagnostic.create({
-                    severity: ErrorSeverity.InvalidReact,
-                    category: ErrorCategory.UseMemo,
-                    reason: 'useMemo() callbacks must return a value',
-                    description: `This ${
-                      manualMemo.loadInstr.value.kind === 'PropertyLoad'
-                        ? 'React.useMemo'
-                        : 'useMemo'
-                    } callback doesn't return a value. useMemo is for computing and caching values, not for arbitrary side effects.`,
-                    suggestions: null,
-                  }).withDetail({
-                    kind: 'error',
-                    loc: instr.value.loc,
-                    message: 'useMemo() callbacks must return a value',
-                  }),
-                );
-              }
-            }
-          }
-
          instr.value = getManualMemoizationReplacement(
            fnPlace,
            instr.value.loc,
@@ -502,20 +408,11 @@ export function dropManualMemoization(
             * is rare and likely sketchy.
             */
            if (!sidemap.functions.has(fnPlace.identifier.id)) {
-              errors.pushDiagnostic(
-                CompilerDiagnostic.create({
-                  category: ErrorCategory.UseMemo,
-                  severity: ErrorSeverity.InvalidReact,
-                  reason: `Expected the first argument to be an inline function expression`,
-                  description: `Expected the first argument to be an inline function expression`,
-                  suggestions: [],
-                }).withDetail({
-                  kind: 'error',
-                  loc: fnPlace.loc,
-                  message: `Expected the first argument to be an inline function expression`,
-                }),
-              );
-              continue;
+              CompilerError.throwInvalidReact({
+                reason: `Expected the first argument to be an inline function expression`,
+                suggestions: [],
+                loc: fnPlace.loc,
+              });
            }
            const memoDecl: Place =
              manualMemo.kind === 'useMemo'
@@ -587,8 +484,6 @@ export function dropManualMemoization(
      markInstructionIds(func.body);
    }
  }
-
-  return errors.asResult();
 }

 function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {
@@ -633,17 +528,3 @@ function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {
  }
  return optionals;
 }
-
-function hasNonVoidReturn(func: HIRFunction): boolean {
-  for (const [, block] of func.body.blocks) {
-    if (block.terminal.kind === 'return') {
-      if (
-        block.terminal.returnVariant === 'Explicit' ||
-        block.terminal.returnVariant === 'Implicit'
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAlias.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAlias.ts
@@ -0,0 +1,68 @@
+/**
+ * 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 {
+  HIRFunction,
+  Identifier,
+  Instruction,
+  isPrimitiveType,
+  Place,
+} from '../HIR/HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+export type AliasSet = Set<Identifier>;
+
+export function inferAliases(func: HIRFunction): DisjointSet<Identifier> {
+  const aliases = new DisjointSet<Identifier>();
+  for (const [_, block] of func.body.blocks) {
+    for (const instr of block.instructions) {
+      inferInstr(instr, aliases);
+    }
+  }
+
+  return aliases;
+}
+
+function inferInstr(
+  instr: Instruction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  const {lvalue, value: instrValue} = instr;
+  let alias: Place | null = null;
+  switch (instrValue.kind) {
+    case 'LoadLocal':
+    case 'LoadContext': {
+      if (isPrimitiveType(instrValue.place.identifier)) {
+        return;
+      }
+      alias = instrValue.place;
+      break;
+    }
+    case 'StoreLocal':
+    case 'StoreContext': {
+      alias = instrValue.value;
+      break;
+    }
+    case 'Destructure': {
+      alias = instrValue.value;
+      break;
+    }
+    case 'ComputedLoad':
+    case 'PropertyLoad': {
+      alias = instrValue.object;
+      break;
+    }
+    case 'TypeCastExpression': {
+      alias = instrValue.value;
+      break;
+    }
+    default:
+      return;
+  }
+
+  aliases.union([lvalue.identifier, alias.identifier]);
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAliasForPhis.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAliasForPhis.ts
@@ -0,0 +1,27 @@
+/**
+ * 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 {HIRFunction, Identifier} from '../HIR/HIR';
+import DisjointSet from '../Utils/DisjointSet';
+
+export function inferAliasForPhis(
+  func: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  for (const [_, block] of func.body.blocks) {
+    for (const phi of block.phis) {
+      const isPhiMutatedAfterCreation: boolean =
+        phi.place.identifier.mutableRange.end >
+        (block.instructions.at(0)?.id ?? block.terminal.id);
+      if (isPhiMutatedAfterCreation) {
+        for (const [, operand] of phi.operands) {
+          aliases.union([phi.place.identifier, operand.identifier]);
+        }
+      }
+    }
+  }
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAliasForStores.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferAliasForStores.ts
@@ -0,0 +1,68 @@
+/**
+ * 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 {
+  Effect,
+  HIRFunction,
+  Identifier,
+  InstructionId,
+  Place,
+} from '../HIR/HIR';
+import {
+  eachInstructionLValue,
+  eachInstructionValueOperand,
+} from '../HIR/visitors';
+import DisjointSet from '../Utils/DisjointSet';
+
+export function inferAliasForStores(
+  func: HIRFunction,
+  aliases: DisjointSet<Identifier>,
+): void {
+  for (const [_, block] of func.body.blocks) {
+    for (const instr of block.instructions) {
+      const {value, lvalue} = instr;
+      const isStore =
+        lvalue.effect === Effect.Store ||
+        /*
+         * Some typed functions annotate callees or arguments
+         * as Effect.Store.
+         */
+        ![...eachInstructionValueOperand(value)].every(
+          operand => operand.effect !== Effect.Store,
+        );
+
+      if (!isStore) {
+        continue;
+      }
+      for (const operand of eachInstructionLValue(instr)) {
+        maybeAlias(aliases, lvalue, operand, instr.id);
+      }
+      for (const operand of eachInstructionValueOperand(value)) {
+        if (
+          operand.effect === Effect.Capture ||
+          operand.effect === Effect.Store
+        ) {
+          maybeAlias(aliases, lvalue, operand, instr.id);
+        }
+      }
+    }
+  }
+}
+
+function maybeAlias(
+  aliases: DisjointSet<Identifier>,
+  lvalue: Place,
+  rvalue: Place,
+  id: InstructionId,
+): void {
+  if (
+    lvalue.identifier.mutableRange.end > id + 1 ||
+    rvalue.identifier.mutableRange.end > id
+  ) {
+    aliases.union([lvalue.identifier, rvalue.identifier]);
+  }
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferEffectDependencies.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferEffectDependencies.ts
@@ -1,15 +1,8 @@
-/**
- * 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 * as t from '@babel/types';
 import {CompilerError, SourceLocation} from '..';
 import {
  ArrayExpression,
  Effect,
+  Environment,
  FunctionExpression,
  GeneratedSource,
  HIRFunction,
@@ -21,50 +14,25 @@ import {
  ScopeId,
  ReactiveScopeDependency,
  Place,
-  ReactiveScope,
  ReactiveScopeDependencies,
-  Terminal,
  isUseRefType,
  isSetStateType,
-  isFireFunctionType,
-  makeScopeId,
-  HIR,
-  BasicBlock,
-  BlockId,
-  isEffectEventFunctionType,
 } from '../HIR';
-import {collectHoistablePropertyLoadsInInnerFn} from '../HIR/CollectHoistablePropertyLoads';
-import {collectOptionalChainSidemap} from '../HIR/CollectOptionalChainDependencies';
-import {ReactiveScopeDependencyTreeHIR} from '../HIR/DeriveMinimalDependenciesHIR';
 import {DEFAULT_EXPORT} from '../HIR/Environment';
 import {
  createTemporaryPlace,
  fixScopeAndIdentifierRanges,
  markInstructionIds,
-  markPredecessors,
-  reversePostorderBlocks,
 } from '../HIR/HIRBuilder';
-import {
-  collectTemporariesSidemap,
-  DependencyCollectionContext,
-  handleInstruction,
-} from '../HIR/PropagateScopeDependenciesHIR';
-import {buildDependencyInstructions} from '../HIR/ScopeDependencyUtils';
-import {
-  eachInstructionOperand,
-  eachTerminalOperand,
-  terminalFallthrough,
-} from '../HIR/visitors';
-import {empty} from '../Utils/Stack';
+import {eachInstructionOperand, eachTerminalOperand} from '../HIR/visitors';
 import {getOrInsertWith} from '../Utils/utils';
-import {deadCodeElimination} from '../Optimization';
-import {BuiltInAutodepsId} from '../HIR/ObjectShape';

 /**
 * Infers reactive dependencies captured by useEffect lambdas and adds them as
 * a second argument to the useEffect call if no dependency array is provided.
 */
 export function inferEffectDependencies(fn: HIRFunction): void {
+  let hasRewrite = false;
  const fnExpressions = new Map<
    IdentifierId,
    TInstruction<FunctionExpression>
@@ -79,13 +47,16 @@ export function inferEffectDependencies(fn: HIRFunction): void {
    );
    moduleTargets.set(
      effectTarget.function.importSpecifierName,
-      effectTarget.autodepsIndex,
+      effectTarget.numRequiredArgs,
    );
  }
  const autodepFnLoads = new Map<IdentifierId, number>();
  const autodepModuleLoads = new Map<IdentifierId, Map<string, number>>();

-  const scopeInfos = new Map<ScopeId, ReactiveScopeDependencies>();
+  const scopeInfos = new Map<
+    ScopeId,
+    {pruned: boolean; deps: ReactiveScopeDependencies; hasSingleInstr: boolean}
+  >();

  const loadGlobals = new Set<IdentifierId>();

@@ -97,23 +68,23 @@ export function inferEffectDependencies(fn: HIRFunction): void {
   * reactive(Identifier i) = Union_{reference of i}(reactive(reference))
   */
  const reactiveIds = inferReactiveIdentifiers(fn);
-  const rewriteBlocks: Array<BasicBlock> = [];

  for (const [, block] of fn.body.blocks) {
-    if (block.terminal.kind === 'scope') {
+    if (
+      block.terminal.kind === 'scope' ||
+      block.terminal.kind === 'pruned-scope'
+    ) {
      const scopeBlock = fn.body.blocks.get(block.terminal.block)!;
-      if (
-        scopeBlock.instructions.length === 1 &&
-        scopeBlock.terminal.kind === 'goto' &&
-        scopeBlock.terminal.block === block.terminal.fallthrough
-      ) {
-        scopeInfos.set(
-          block.terminal.scope.id,
-          block.terminal.scope.dependencies,
-        );
-      }
+      scopeInfos.set(block.terminal.scope.id, {
+        pruned: block.terminal.kind === 'pruned-scope',
+        deps: block.terminal.scope.dependencies,
+        hasSingleInstr:
+          scopeBlock.instructions.length === 1 &&
+          scopeBlock.terminal.kind === 'goto' &&
+          scopeBlock.terminal.block === block.terminal.fallthrough,
+      });
    }
-    const rewriteInstrs: Array<SpliceInfo> = [];
+    const rewriteInstrs = new Map<InstructionId, Array<Instruction>>();
    for (const instr of block.instructions) {
      const {value, lvalue} = instr;
      if (value.kind === 'FunctionExpression') {
@@ -137,6 +108,7 @@ export function inferEffectDependencies(fn: HIRFunction): void {
        }
      } else if (value.kind === 'LoadGlobal') {
        loadGlobals.add(lvalue.identifier.id);
+
        /*
         * TODO: Handle properties on default exports, like
         * import React from 'react';
@@ -170,26 +142,13 @@ export function inferEffectDependencies(fn: HIRFunction): void {
      ) {
        const callee =
          value.kind === 'CallExpression' ? value.callee : value.property;
-
-        const autodepsArgIndex = value.args.findIndex(
-          arg =>
-            arg.kind === 'Identifier' &&
-            arg.identifier.type.kind === 'Object' &&
-            arg.identifier.type.shapeId === BuiltInAutodepsId,
-        );
-        const autodepsArgExpectedIndex = autodepFnLoads.get(
-          callee.identifier.id,
-        );
-
        if (
-          value.args.length > 0 &&
-          autodepsArgExpectedIndex != null &&
-          autodepsArgIndex === autodepsArgExpectedIndex &&
-          autodepFnLoads.has(callee.identifier.id) &&
+          value.args.length === autodepFnLoads.get(callee.identifier.id) &&
          value.args[0].kind === 'Identifier'
        ) {
          // We have a useEffect call with no deps array, so we need to infer the deps
          const effectDeps: Array<Place> = [];
+          const newInstructions: Array<Instruction> = [];
          const deps: ArrayExpression = {
            kind: 'ArrayExpression',
            elements: effectDeps,
@@ -205,12 +164,22 @@ export function inferEffectDependencies(fn: HIRFunction): void {
              fnExpr.lvalue.identifier.scope != null
                ? scopeInfos.get(fnExpr.lvalue.identifier.scope.id)
                : null;
-            let minimalDeps: Set<ReactiveScopeDependency>;
-            if (scopeInfo != null) {
-              minimalDeps = new Set(scopeInfo);
-            } else {
-              minimalDeps = inferMinimalDependencies(fnExpr);
+            CompilerError.invariant(scopeInfo != null, {
+              reason: 'Expected function expression scope to exist',
+              loc: value.loc,
+            });
+            if (scopeInfo.pruned || !scopeInfo.hasSingleInstr) {
+              /**
+               * TODO: retry pipeline that ensures effect function expressions
+               * are placed into their own scope
+               */
+              CompilerError.throwTodo({
+                reason:
+                  '[InferEffectDependencies] Expected effect function to have non-pruned scope and its scope to have exactly one instruction',
+                loc: fnExpr.loc,
+              });
            }
+
            /**
             * Step 1: push dependencies to the effect deps array
             *
@@ -218,275 +187,128 @@ export function inferEffectDependencies(fn: HIRFunction): void {
             * the `infer-effect-deps/pruned-nonreactive-obj` fixture for an
             * explanation.
             */
-
-            const usedDeps = [];
-            for (const maybeDep of minimalDeps) {
+            for (const dep of scopeInfo.deps) {
              if (
-                ((isUseRefType(maybeDep.identifier) ||
-                  isSetStateType(maybeDep.identifier)) &&
-                  !reactiveIds.has(maybeDep.identifier.id)) ||
-                isFireFunctionType(maybeDep.identifier) ||
-                isEffectEventFunctionType(maybeDep.identifier)
+                (isUseRefType(dep.identifier) ||
+                  isSetStateType(dep.identifier)) &&
+                !reactiveIds.has(dep.identifier.id)
              ) {
                // exclude non-reactive hook results, which will never be in a memo block
                continue;
              }

-              const dep = truncateDepAtCurrent(maybeDep);
-              const {place, value, exitBlockId} = buildDependencyInstructions(
+              const {place, instructions} = writeDependencyToInstructions(
                dep,
+                reactiveIds.has(dep.identifier.id),
                fn.env,
+                fnExpr.loc,
              );
-              rewriteInstrs.push({
-                kind: 'block',
-                location: instr.id,
-                value,
-                exitBlockId: exitBlockId,
-              });
+              newInstructions.push(...instructions);
              effectDeps.push(place);
-              usedDeps.push(dep);
            }

-            // For LSP autodeps feature.
-            const decorations: Array<t.SourceLocation> = [];
-            for (const loc of collectDepUsages(usedDeps, fnExpr.value)) {
-              if (typeof loc === 'symbol') {
-                continue;
-              }
-              decorations.push(loc);
-            }
-            if (typeof value.loc !== 'symbol') {
-              fn.env.logger?.logEvent(fn.env.filename, {
-                kind: 'AutoDepsDecorations',
-                fnLoc: value.loc,
-                decorations,
-              });
-            }
+            newInstructions.push({
+              id: makeInstructionId(0),
+              loc: GeneratedSource,
+              lvalue: {...depsPlace, effect: Effect.Mutate},
+              value: deps,
+            });

            // Step 2: push the inferred deps array as an argument of the useEffect
-            rewriteInstrs.push({
-              kind: 'instr',
-              location: instr.id,
-              value: {
-                id: makeInstructionId(0),
-                loc: GeneratedSource,
-                lvalue: {...depsPlace, effect: Effect.Mutate},
-                value: deps,
-                effects: null,
-              },
-            });
-            value.args[autodepsArgIndex] = {
-              ...depsPlace,
-              effect: Effect.Freeze,
-            };
-            fn.env.inferredEffectLocations.add(callee.loc);
+            value.args.push({...depsPlace, effect: Effect.Freeze});
+            rewriteInstrs.set(instr.id, newInstructions);
          } else if (loadGlobals.has(value.args[0].identifier.id)) {
            // Global functions have no reactive dependencies, so we can insert an empty array
-            rewriteInstrs.push({
-              kind: 'instr',
-              location: instr.id,
-              value: {
-                id: makeInstructionId(0),
-                loc: GeneratedSource,
-                lvalue: {...depsPlace, effect: Effect.Mutate},
-                value: deps,
-                effects: null,
-              },
-            });
-            value.args[autodepsArgIndex] = {
-              ...depsPlace,
-              effect: Effect.Freeze,
-            };
-            fn.env.inferredEffectLocations.add(callee.loc);
-          }
-        } else if (
-          value.args.length >= 2 &&
-          value.args.length - 1 === autodepFnLoads.get(callee.identifier.id) &&
-          value.args[0] != null &&
-          value.args[0].kind === 'Identifier'
-        ) {
-          const penultimateArg = value.args[value.args.length - 2];
-          const depArrayArg = value.args[value.args.length - 1];
-          if (
-            depArrayArg.kind !== 'Spread' &&
-            penultimateArg.kind !== 'Spread' &&
-            typeof depArrayArg.loc !== 'symbol' &&
-            typeof penultimateArg.loc !== 'symbol' &&
-            typeof value.loc !== 'symbol'
-          ) {
-            fn.env.logger?.logEvent(fn.env.filename, {
-              kind: 'AutoDepsEligible',
-              fnLoc: value.loc,
-              depArrayLoc: {
-                ...depArrayArg.loc,
-                start: penultimateArg.loc.end,
-                end: depArrayArg.loc.end,
-              },
+            newInstructions.push({
+              id: makeInstructionId(0),
+              loc: GeneratedSource,
+              lvalue: {...depsPlace, effect: Effect.Mutate},
+              value: deps,
            });
+            value.args.push({...depsPlace, effect: Effect.Freeze});
+            rewriteInstrs.set(instr.id, newInstructions);
          }
        }
      }
    }
-    rewriteSplices(block, rewriteInstrs, rewriteBlocks);
-  }
-
-  if (rewriteBlocks.length > 0) {
-    for (const block of rewriteBlocks) {
-      fn.body.blocks.set(block.id, block);
+    if (rewriteInstrs.size > 0) {
+      hasRewrite = true;
+      const newInstrs = [];
+      for (const instr of block.instructions) {
+        const newInstr = rewriteInstrs.get(instr.id);
+        if (newInstr != null) {
+          newInstrs.push(...newInstr, instr);
+        } else {
+          newInstrs.push(instr);
+        }
+      }
+      block.instructions = newInstrs;
    }
-
-    /**
-     * Fixup the HIR to restore RPO, ensure correct predecessors, and renumber
-     * instructions.
-     */
-    reversePostorderBlocks(fn.body);
-    markPredecessors(fn.body);
+  }
+  if (hasRewrite) {
    // Renumber instructions and fix scope ranges
    markInstructionIds(fn.body);
    fixScopeAndIdentifierRanges(fn.body);
-    deadCodeElimination(fn);
-
-    fn.env.hasInferredEffect = true;
  }
 }

-function truncateDepAtCurrent(
+function writeDependencyToInstructions(
  dep: ReactiveScopeDependency,
-): ReactiveScopeDependency {
-  const idx = dep.path.findIndex(path => path.property === 'current');
-  if (idx === -1) {
-    return dep;
-  } else {
-    return {...dep, path: dep.path.slice(0, idx)};
-  }
-}
-
-type SpliceInfo =
-  | {kind: 'instr'; location: InstructionId; value: Instruction}
-  | {
-      kind: 'block';
-      location: InstructionId;
-      value: HIR;
-      exitBlockId: BlockId;
-    };
-
-function rewriteSplices(
-  originalBlock: BasicBlock,
-  splices: Array<SpliceInfo>,
-  rewriteBlocks: Array<BasicBlock>,
-): void {
-  if (splices.length === 0) {
-    return;
-  }
-  /**
-   * Splice instructions or value blocks into the original block.
-   * --- original block ---
-   * bb_original
-   *   instr1
-   *   ...
-   *   instr2 <-- splice location
-   *   instr3
-   *   ...
-   *   <original terminal>
-   *
-   * If there is more than one block in the splice, this means that we're
-   * splicing in a set of value-blocks of the following structure:
-   * --- blocks we're splicing in ---
-   * bb_entry:
-   *   instrEntry
-   *   ...
-   *   <splice terminal> fallthrough=bb_exit
-   *
-   * bb1(value):
-   *   ...
-   *
-   * bb_exit:
-   *   instrExit
-   *   ...
-   *   <synthetic terminal>
-   *
-   *
-   * --- rewritten blocks ---
-   * bb_original
-   *   instr1
-   *   ... (original instructions)
-   *   instr2
-   *   instrEntry
-   *   ... (spliced instructions)
-   *   <splice terminal> fallthrough=bb_exit
-   *
-   * bb1(value):
-   *   ...
-   *
-   * bb_exit:
-   *   instrExit
-   *   ... (spliced instructions)
-   *   instr3
-   *   ... (original instructions)
-   *   <original terminal>
-   */
-  const originalInstrs = originalBlock.instructions;
-  let currBlock: BasicBlock = {...originalBlock, instructions: []};
-  rewriteBlocks.push(currBlock);
-
-  let cursor = 0;
-
-  for (const rewrite of splices) {
-    while (originalInstrs[cursor].id < rewrite.location) {
-      CompilerError.invariant(
-        originalInstrs[cursor].id < originalInstrs[cursor + 1].id,
-        {
-          reason:
-            '[InferEffectDependencies] Internal invariant broken: expected block instructions to be sorted',
-          loc: originalInstrs[cursor].loc,
-        },
-      );
-      currBlock.instructions.push(originalInstrs[cursor]);
-      cursor++;
+  reactive: boolean,
+  env: Environment,
+  loc: SourceLocation,
+): {place: Place; instructions: Array<Instruction>} {
+  const instructions: Array<Instruction> = [];
+  let currValue = createTemporaryPlace(env, GeneratedSource);
+  currValue.reactive = reactive;
+  instructions.push({
+    id: makeInstructionId(0),
+    loc: GeneratedSource,
+    lvalue: {...currValue, effect: Effect.Mutate},
+    value: {
+      kind: 'LoadLocal',
+      place: {
+        kind: 'Identifier',
+        identifier: dep.identifier,
+        effect: Effect.Capture,
+        reactive,
+        loc: loc,
+      },
+      loc: loc,
+    },
+  });
+  for (const path of dep.path) {
+    if (path.optional) {
+      /**
+       * TODO: instead of truncating optional paths, reuse
+       * instructions from hoisted dependencies block(s)
+       */
+      break;
    }
-    CompilerError.invariant(originalInstrs[cursor].id === rewrite.location, {
-      reason:
-        '[InferEffectDependencies] Internal invariant broken: splice location not found',
-      loc: originalInstrs[cursor].loc,
+    if (path.property === 'current') {
+      /*
+       * Prune ref.current accesses. This may over-capture for non-ref values with
+       * a current property, but that's fine.
+       */
+      break;
+    }
+    const nextValue = createTemporaryPlace(env, GeneratedSource);
+    nextValue.reactive = reactive;
+    instructions.push({
+      id: makeInstructionId(0),
+      loc: GeneratedSource,
+      lvalue: {...nextValue, effect: Effect.Mutate},
+      value: {
+        kind: 'PropertyLoad',
+        object: {...currValue, effect: Effect.Capture},
+        property: path.property,
+        loc: loc,
+      },
    });
-
-    if (rewrite.kind === 'instr') {
-      currBlock.instructions.push(rewrite.value);
-    } else if (rewrite.kind === 'block') {
-      const {entry, blocks} = rewrite.value;
-      const entryBlock = blocks.get(entry)!;
-      // splice in all instructions from the entry block
-      currBlock.instructions.push(...entryBlock.instructions);
-      if (blocks.size > 1) {
-        /**
-         * We're splicing in a set of value-blocks, which means we need
-         * to push new blocks and update terminals.
-         */
-        CompilerError.invariant(
-          terminalFallthrough(entryBlock.terminal) === rewrite.exitBlockId,
-          {
-            reason:
-              '[InferEffectDependencies] Internal invariant broken: expected entry block to have a fallthrough',
-            loc: entryBlock.terminal.loc,
-          },
-        );
-        const originalTerminal = currBlock.terminal;
-        currBlock.terminal = entryBlock.terminal;
-
-        for (const [id, block] of blocks) {
-          if (id === entry) {
-            continue;
-          }
-          if (id === rewrite.exitBlockId) {
-            block.terminal = originalTerminal;
-            currBlock = block;
-          }
-          rewriteBlocks.push(block);
-        }
-      }
-    }
+    currValue = nextValue;
  }
-  currBlock.instructions.push(...originalInstrs.slice(cursor));
+  currValue.effect = Effect.Freeze;
+  return {place: currValue, instructions};
 }

 function inferReactiveIdentifiers(fn: HIRFunction): Set<IdentifierId> {
@@ -513,163 +335,3 @@ function inferReactiveIdentifiers(fn: HIRFunction): Set<IdentifierId> {
  }
  return reactiveIds;
 }
-
-function collectDepUsages(
-  deps: Array<ReactiveScopeDependency>,
-  fnExpr: FunctionExpression,
-): Array<SourceLocation> {
-  const identifiers: Map<IdentifierId, ReactiveScopeDependency> = new Map();
-  const loadedDeps: Set<IdentifierId> = new Set();
-  const sourceLocations = [];
-  for (const dep of deps) {
-    identifiers.set(dep.identifier.id, dep);
-  }
-
-  for (const [, block] of fnExpr.loweredFunc.func.body.blocks) {
-    for (const instr of block.instructions) {
-      if (
-        instr.value.kind === 'LoadLocal' &&
-        identifiers.has(instr.value.place.identifier.id)
-      ) {
-        loadedDeps.add(instr.lvalue.identifier.id);
-      }
-      for (const place of eachInstructionOperand(instr)) {
-        if (loadedDeps.has(place.identifier.id)) {
-          // TODO(@jbrown215): handle member exprs!!
-          sourceLocations.push(place.identifier.loc);
-        }
-      }
-    }
-  }
-
-  return sourceLocations;
-}
-
-function inferMinimalDependencies(
-  fnInstr: TInstruction<FunctionExpression>,
-): Set<ReactiveScopeDependency> {
-  const fn = fnInstr.value.loweredFunc.func;
-
-  const temporaries = collectTemporariesSidemap(fn, new Set());
-  const {
-    hoistableObjects,
-    processedInstrsInOptional,
-    temporariesReadInOptional,
-  } = collectOptionalChainSidemap(fn);
-
-  const hoistablePropertyLoads = collectHoistablePropertyLoadsInInnerFn(
-    fnInstr,
-    temporaries,
-    hoistableObjects,
-  );
-  const hoistableToFnEntry = hoistablePropertyLoads.get(fn.body.entry);
-  CompilerError.invariant(hoistableToFnEntry != null, {
-    reason:
-      '[InferEffectDependencies] Internal invariant broken: missing entry block',
-    loc: fnInstr.loc,
-  });
-
-  const dependencies = inferDependencies(
-    fnInstr,
-    new Map([...temporaries, ...temporariesReadInOptional]),
-    processedInstrsInOptional,
-  );
-
-  const tree = new ReactiveScopeDependencyTreeHIR(
-    [...hoistableToFnEntry.assumedNonNullObjects].map(o => o.fullPath),
-  );
-  for (const dep of dependencies) {
-    tree.addDependency({...dep});
-  }
-
-  return tree.deriveMinimalDependencies();
-}
-
-function inferDependencies(
-  fnInstr: TInstruction<FunctionExpression>,
-  temporaries: ReadonlyMap<IdentifierId, ReactiveScopeDependency>,
-  processedInstrsInOptional: ReadonlySet<Instruction | Terminal>,
-): Set<ReactiveScopeDependency> {
-  const fn = fnInstr.value.loweredFunc.func;
-  const context = new DependencyCollectionContext(
-    new Set(),
-    temporaries,
-    processedInstrsInOptional,
-  );
-  for (const dep of fn.context) {
-    context.declare(dep.identifier, {
-      id: makeInstructionId(0),
-      scope: empty(),
-    });
-  }
-  const placeholderScope: ReactiveScope = {
-    id: makeScopeId(0),
-    range: {
-      start: fnInstr.id,
-      end: makeInstructionId(fnInstr.id + 1),
-    },
-    dependencies: new Set(),
-    reassignments: new Set(),
-    declarations: new Map(),
-    earlyReturnValue: null,
-    merged: new Set(),
-    loc: GeneratedSource,
-  };
-  context.enterScope(placeholderScope);
-  inferDependenciesInFn(fn, context, temporaries);
-  context.exitScope(placeholderScope, false);
-  const resultUnfiltered = context.deps.get(placeholderScope);
-  CompilerError.invariant(resultUnfiltered != null, {
-    reason:
-      '[InferEffectDependencies] Internal invariant broken: missing scope dependencies',
-    loc: fn.loc,
-  });
-
-  const fnContext = new Set(fn.context.map(dep => dep.identifier.id));
-  const result = new Set<ReactiveScopeDependency>();
-  for (const dep of resultUnfiltered) {
-    if (fnContext.has(dep.identifier.id)) {
-      result.add(dep);
-    }
-  }
-
-  return result;
-}
-
-function inferDependenciesInFn(
-  fn: HIRFunction,
-  context: DependencyCollectionContext,
-  temporaries: ReadonlyMap<IdentifierId, ReactiveScopeDependency>,
-): void {
-  for (const [, block] of fn.body.blocks) {
-    // Record referenced optional chains in phis
-    for (const phi of block.phis) {
-      for (const operand of phi.operands) {
-        const maybeOptionalChain = temporaries.get(operand[1].identifier.id);
-        if (maybeOptionalChain) {
-          context.visitDependency(maybeOptionalChain);
-        }
-      }
-    }
-    for (const instr of block.instructions) {
-      if (
-        instr.value.kind === 'FunctionExpression' ||
-        instr.value.kind === 'ObjectMethod'
-      ) {
-        context.declare(instr.lvalue.identifier, {
-          id: instr.id,
-          scope: context.currentScope,
-        });
-        /**
-         * Recursively visit the inner function to extract dependencies
-         */
-        const innerFn = instr.value.loweredFunc.func;
-        context.enterInnerFn(instr as TInstruction<FunctionExpression>, () => {
-          inferDependenciesInFn(innerFn, context, temporaries);
-        });
-      } else {
-        handleInstruction(instr, context);
-      }
-    }
-  }
-}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferFunctionEffects.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferFunctionEffects.ts
@@ -0,0 +1,345 @@
+/**
+ * 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,
+  CompilerErrorDetailOptions,
+  ErrorSeverity,
+  ValueKind,
+} from '..';
+import {
+  AbstractValue,
+  BasicBlock,
+  Effect,
+  Environment,
+  FunctionEffect,
+  Instruction,
+  InstructionValue,
+  Place,
+  ValueReason,
+  getHookKind,
+  isRefOrRefValue,
+} from '../HIR';
+import {eachInstructionOperand, eachTerminalOperand} from '../HIR/visitors';
+import {assertExhaustive} from '../Utils/utils';
+
+interface State {
+  kind(place: Place): AbstractValue;
+  values(place: Place): Array<InstructionValue>;
+  isDefined(place: Place): boolean;
+}
+
+function inferOperandEffect(state: State, place: Place): null | FunctionEffect {
+  const value = state.kind(place);
+  CompilerError.invariant(value != null, {
+    reason: 'Expected operand to have a kind',
+    loc: null,
+  });
+
+  switch (place.effect) {
+    case Effect.Store:
+    case Effect.Mutate: {
+      if (isRefOrRefValue(place.identifier)) {
+        break;
+      } else if (value.kind === ValueKind.Context) {
+        CompilerError.invariant(value.context.size > 0, {
+          reason:
+            "[InferFunctionEffects] Expected Context-kind value's capture list to be non-empty.",
+          loc: place.loc,
+        });
+        return {
+          kind: 'ContextMutation',
+          loc: place.loc,
+          effect: place.effect,
+          places: value.context,
+        };
+      } else if (
+        value.kind !== ValueKind.Mutable &&
+        // We ignore mutations of primitives since this is not a React-specific problem
+        value.kind !== ValueKind.Primitive
+      ) {
+        let reason = getWriteErrorReason(value);
+        return {
+          kind:
+            value.reason.size === 1 && value.reason.has(ValueReason.Global)
+              ? 'GlobalMutation'
+              : 'ReactMutation',
+          error: {
+            reason,
+            description:
+              place.identifier.name !== null &&
+              place.identifier.name.kind === 'named'
+                ? `Found mutation of \`${place.identifier.name.value}\``
+                : null,
+            loc: place.loc,
+            suggestions: null,
+            severity: ErrorSeverity.InvalidReact,
+          },
+        };
+      }
+      break;
+    }
+  }
+  return null;
+}
+
+function inheritFunctionEffects(
+  state: State,
+  place: Place,
+): Array<FunctionEffect> {
+  const effects = inferFunctionInstrEffects(state, place);
+
+  return effects
+    .flatMap(effect => {
+      if (effect.kind === 'GlobalMutation' || effect.kind === 'ReactMutation') {
+        return [effect];
+      } else {
+        const effects: Array<FunctionEffect | null> = [];
+        CompilerError.invariant(effect.kind === 'ContextMutation', {
+          reason: 'Expected ContextMutation',
+          loc: null,
+        });
+        /**
+         * Contextual effects need to be replayed against the current inference
+         * state, which may know more about the value to which the effect applied.
+         * The main cases are:
+         * 1. The mutated context value is _still_ a context value in the current scope,
+         *    so we have to continue propagating the original context mutation.
+         * 2. The mutated context value is a mutable value in the current scope,
+         *    so the context mutation was fine and we can skip propagating the effect.
+         * 3. The mutated context value  is an immutable value in the current scope,
+         *    resulting in a non-ContextMutation FunctionEffect. We propagate that new,
+         *    more detailed effect to the current function context.
+         */
+        for (const place of effect.places) {
+          if (state.isDefined(place)) {
+            const replayedEffect = inferOperandEffect(state, {
+              ...place,
+              loc: effect.loc,
+              effect: effect.effect,
+            });
+            if (replayedEffect != null) {
+              if (replayedEffect.kind === 'ContextMutation') {
+                // Case 1, still a context value so propagate the original effect
+                effects.push(effect);
+              } else {
+                // Case 3, immutable value so propagate the more precise effect
+                effects.push(replayedEffect);
+              }
+            } // else case 2, local mutable value so this effect was fine
+          }
+        }
+        return effects;
+      }
+    })
+    .filter((effect): effect is FunctionEffect => effect != null);
+}
+
+function inferFunctionInstrEffects(
+  state: State,
+  place: Place,
+): Array<FunctionEffect> {
+  const effects: Array<FunctionEffect> = [];
+  const instrs = state.values(place);
+  CompilerError.invariant(instrs != null, {
+    reason: 'Expected operand to have instructions',
+    loc: null,
+  });
+
+  for (const instr of instrs) {
+    if (
+      (instr.kind === 'FunctionExpression' || instr.kind === 'ObjectMethod') &&
+      instr.loweredFunc.func.effects != null
+    ) {
+      effects.push(...instr.loweredFunc.func.effects);
+    }
+  }
+
+  return effects;
+}
+
+function operandEffects(
+  state: State,
+  place: Place,
+  filterRenderSafe: boolean,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  const effect = inferOperandEffect(state, place);
+  effect && functionEffects.push(effect);
+  functionEffects.push(...inheritFunctionEffects(state, place));
+  if (filterRenderSafe) {
+    return functionEffects.filter(effect => !isEffectSafeOutsideRender(effect));
+  } else {
+    return functionEffects;
+  }
+}
+
+export function inferInstructionFunctionEffects(
+  env: Environment,
+  state: State,
+  instr: Instruction,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  switch (instr.value.kind) {
+    case 'JsxExpression': {
+      if (instr.value.tag.kind === 'Identifier') {
+        functionEffects.push(...operandEffects(state, instr.value.tag, false));
+      }
+      instr.value.children?.forEach(child =>
+        functionEffects.push(...operandEffects(state, child, false)),
+      );
+      for (const attr of instr.value.props) {
+        if (attr.kind === 'JsxSpreadAttribute') {
+          functionEffects.push(...operandEffects(state, attr.argument, false));
+        } else {
+          functionEffects.push(...operandEffects(state, attr.place, true));
+        }
+      }
+      break;
+    }
+    case 'ObjectMethod':
+    case 'FunctionExpression': {
+      /**
+       * If this function references other functions, propagate the referenced function's
+       * effects to this function.
+       *
+       * ```
+       * let f = () => global = true;
+       * let g = () => f();
+       * g();
+       * ```
+       *
+       * In this example, because `g` references `f`, we propagate the GlobalMutation from
+       * `f` to `g`. Thus, referencing `g` in `g()` will evaluate the GlobalMutation in the outer
+       * function effect context and report an error. But if instead we do:
+       *
+       * ```
+       * let f = () => global = true;
+       * let g = () => f();
+       * useEffect(() => g(), [g])
+       * ```
+       *
+       * Now `g`'s effects will be discarded since they're in a useEffect.
+       */
+      for (const operand of eachInstructionOperand(instr)) {
+        instr.value.loweredFunc.func.effects ??= [];
+        instr.value.loweredFunc.func.effects.push(
+          ...inferFunctionInstrEffects(state, operand),
+        );
+      }
+      break;
+    }
+    case 'MethodCall':
+    case 'CallExpression': {
+      let callee;
+      if (instr.value.kind === 'MethodCall') {
+        callee = instr.value.property;
+        functionEffects.push(
+          ...operandEffects(state, instr.value.receiver, false),
+        );
+      } else {
+        callee = instr.value.callee;
+      }
+      functionEffects.push(...operandEffects(state, callee, false));
+      let isHook = getHookKind(env, callee.identifier) != null;
+      for (const arg of instr.value.args) {
+        const place = arg.kind === 'Identifier' ? arg : arg.place;
+        /*
+         * Join the effects of the argument with the effects of the enclosing function,
+         * unless the we're detecting a global mutation inside a useEffect hook
+         */
+        functionEffects.push(...operandEffects(state, place, isHook));
+      }
+      break;
+    }
+    case 'StartMemoize':
+    case 'FinishMemoize':
+    case 'LoadLocal':
+    case 'StoreLocal': {
+      break;
+    }
+    case 'StoreGlobal': {
+      functionEffects.push({
+        kind: 'GlobalMutation',
+        error: {
+          reason:
+            'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
+          loc: instr.loc,
+          suggestions: null,
+          severity: ErrorSeverity.InvalidReact,
+        },
+      });
+      break;
+    }
+    default: {
+      for (const operand of eachInstructionOperand(instr)) {
+        functionEffects.push(...operandEffects(state, operand, false));
+      }
+    }
+  }
+  return functionEffects;
+}
+
+export function inferTerminalFunctionEffects(
+  state: State,
+  block: BasicBlock,
+): Array<FunctionEffect> {
+  const functionEffects: Array<FunctionEffect> = [];
+  for (const operand of eachTerminalOperand(block.terminal)) {
+    functionEffects.push(...operandEffects(state, operand, true));
+  }
+  return functionEffects;
+}
+
+export function transformFunctionEffectErrors(
+  functionEffects: Array<FunctionEffect>,
+): Array<CompilerErrorDetailOptions> {
+  return functionEffects.map(eff => {
+    switch (eff.kind) {
+      case 'ReactMutation':
+      case 'GlobalMutation': {
+        return eff.error;
+      }
+      case 'ContextMutation': {
+        return {
+          severity: ErrorSeverity.Invariant,
+          reason: `Unexpected ContextMutation in top-level function effects`,
+          loc: eff.loc,
+        };
+      }
+      default:
+        assertExhaustive(
+          eff,
+          `Unexpected function effect kind \`${(eff as any).kind}\``,
+        );
+    }
+  });
+}
+
+function isEffectSafeOutsideRender(effect: FunctionEffect): boolean {
+  return effect.kind === 'GlobalMutation';
+}
+
+function getWriteErrorReason(abstractValue: AbstractValue): string {
+  if (abstractValue.reason.has(ValueReason.Global)) {
+    return 'Writing to a variable defined outside a component or hook is not allowed. Consider using an effect';
+  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
+    return 'Updating a value used previously in JSX is not allowed. Consider moving the mutation before the JSX';
+  } else if (abstractValue.reason.has(ValueReason.Context)) {
+    return `Mutating a value returned from 'useContext()', which should not be mutated`;
+  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
+    return 'Mutating a value returned from a function whose return value should not be mutated';
+  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
+    return 'Mutating component props or hook arguments is not allowed. Consider using a local variable instead';
+  } else if (abstractValue.reason.has(ValueReason.State)) {
+    return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
+  } else {
+    return 'This mutates a variable that React considers immutable';
+  }
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutableLifetimes.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutableLifetimes.ts
@@ -0,0 +1,198 @@
+/**
+ * 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 {
+  Effect,
+  HIRFunction,
+  Identifier,
+  InstructionId,
+  InstructionKind,
+  isRefOrRefValue,
+  makeInstructionId,
+  Place,
+} from '../HIR/HIR';
+import {printPlace} from '../HIR/PrintHIR';
+import {
+  eachInstructionLValue,
+  eachInstructionOperand,
+  eachTerminalOperand,
+} from '../HIR/visitors';
+import {assertExhaustive} from '../Utils/utils';
+
+/*
+ * For each usage of a value in the given function, determines if the usage
+ * may be succeeded by a mutable usage of that same value and if so updates
+ * the usage to be mutable.
+ *
+ * Stated differently, this inference ensures that inferred capabilities of
+ * each reference are as follows:
+ * - freeze: the value is frozen at this point
+ * - readonly: the value is not modified at this point *or any subsequent
+ *    point*
+ * - mutable: the value is modified at this point *or some subsequent point*.
+ *
+ * Note that this refines the capabilities inferered by InferReferenceCapability,
+ * which looks at individual references and not the lifetime of a value's mutability.
+ *
+ * == Algorithm
+ *
+ * TODO:
+ * 1. Forward data-flow analysis to determine aliasing. Unlike InferReferenceCapability
+ *     which only tracks aliasing of top-level variables (`y = x`), this analysis needs
+ *     to know if a value is aliased anywhere (`y.x = x`). The forward data flow tracks
+ *     all possible locations which may have aliased a value. The concrete result is
+ *     a mapping of each Place to the set of possibly-mutable values it may alias.
+ *
+ * ```
+ * const x = []; // {x: v0; v0: mutable []}
+ * const y = {}; // {x: v0, y: v1; v0: mutable [], v1: mutable []}
+ * y.x = x;      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
+ * read(x);      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
+ * mutate(y);    // can infer that y mutates v0 and v1
+ * ```
+ *
+ * DONE:
+ * 2. Forward data-flow analysis to compute mutability liveness. Walk forwards over
+ *     the CFG and track which values are mutated in a successor.
+ *
+ * ```
+ * mutate(y);    // mutable y => v0, v1 mutated
+ * read(x);      // x maps to v0, v1, those are in the mutated-later set, so x is mutable here
+ * ...
+ * ```
+ */
+
+function infer(place: Place, instrId: InstructionId): void {
+  if (!isRefOrRefValue(place.identifier)) {
+    place.identifier.mutableRange.end = makeInstructionId(instrId + 1);
+  }
+}
+
+function inferPlace(
+  place: Place,
+  instrId: InstructionId,
+  inferMutableRangeForStores: boolean,
+): void {
+  switch (place.effect) {
+    case Effect.Unknown: {
+      throw new Error(`Found an unknown place ${printPlace(place)}}!`);
+    }
+    case Effect.Capture:
+    case Effect.Read:
+    case Effect.Freeze:
+      return;
+    case Effect.Store:
+      if (inferMutableRangeForStores) {
+        infer(place, instrId);
+      }
+      return;
+    case Effect.ConditionallyMutate:
+    case Effect.Mutate: {
+      infer(place, instrId);
+      return;
+    }
+    default:
+      assertExhaustive(place.effect, `Unexpected ${printPlace(place)} effect`);
+  }
+}
+
+export function inferMutableLifetimes(
+  func: HIRFunction,
+  inferMutableRangeForStores: boolean,
+): void {
+  /*
+   * Context variables only appear to mutate where they are assigned, but we need
+   * to force their range to start at their declaration. Track the declaring instruction
+   * id so that the ranges can be extended if/when they are reassigned
+   */
+  const contextVariableDeclarationInstructions = new Map<
+    Identifier,
+    InstructionId
+  >();
+  for (const [_, block] of func.body.blocks) {
+    for (const phi of block.phis) {
+      const isPhiMutatedAfterCreation: boolean =
+        phi.place.identifier.mutableRange.end >
+        (block.instructions.at(0)?.id ?? block.terminal.id);
+      if (
+        inferMutableRangeForStores &&
+        isPhiMutatedAfterCreation &&
+        phi.place.identifier.mutableRange.start === 0
+      ) {
+        for (const [, operand] of phi.operands) {
+          if (phi.place.identifier.mutableRange.start === 0) {
+            phi.place.identifier.mutableRange.start =
+              operand.identifier.mutableRange.start;
+          } else {
+            phi.place.identifier.mutableRange.start = makeInstructionId(
+              Math.min(
+                phi.place.identifier.mutableRange.start,
+                operand.identifier.mutableRange.start,
+              ),
+            );
+          }
+        }
+      }
+    }
+
+    for (const instr of block.instructions) {
+      for (const operand of eachInstructionLValue(instr)) {
+        const lvalueId = operand.identifier;
+
+        /*
+         * lvalue start being mutable when they're initially assigned a
+         * value.
+         */
+        lvalueId.mutableRange.start = instr.id;
+
+        /*
+         * Let's be optimistic and assume this lvalue is not mutable by
+         * default.
+         */
+        lvalueId.mutableRange.end = makeInstructionId(instr.id + 1);
+      }
+      for (const operand of eachInstructionOperand(instr)) {
+        inferPlace(operand, instr.id, inferMutableRangeForStores);
+      }
+
+      if (
+        instr.value.kind === 'DeclareContext' ||
+        (instr.value.kind === 'StoreContext' &&
+          instr.value.lvalue.kind !== InstructionKind.Reassign)
+      ) {
+        // Save declarations of context variables
+        contextVariableDeclarationInstructions.set(
+          instr.value.lvalue.place.identifier,
+          instr.id,
+        );
+      } else if (instr.value.kind === 'StoreContext') {
+        /*
+         * Else this is a reassignment, extend the range from the declaration (if present).
+         * Note that declarations may not be present for context variables that are reassigned
+         * within a function expression before (or without) a read of the same variable
+         */
+        const declaration = contextVariableDeclarationInstructions.get(
+          instr.value.lvalue.place.identifier,
+        );
+        if (
+          declaration != null &&
+          !isRefOrRefValue(instr.value.lvalue.place.identifier)
+        ) {
+          const range = instr.value.lvalue.place.identifier.mutableRange;
+          if (range.start === 0) {
+            range.start = declaration;
+          } else {
+            range.start = makeInstructionId(Math.min(range.start, declaration));
+          }
+        }
+      }
+    }
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      inferPlace(operand, block.terminal.id, inferMutableRangeForStores);
+    }
+  }
+}
--- a/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutableRanges.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutableRanges.ts
@@ -0,0 +1,100 @@
+/**
+ * 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 {HIRFunction, Identifier} from '../HIR/HIR';
+import {inferAliases} from './InferAlias';
+import {inferAliasForPhis} from './InferAliasForPhis';
+import {inferAliasForStores} from './InferAliasForStores';
+import {inferMutableLifetimes} from './InferMutableLifetimes';
+import {inferMutableRangesForAlias} from './InferMutableRangesForAlias';
+import {inferTryCatchAliases} from './InferTryCatchAliases';
+
+export function inferMutableRanges(ir: HIRFunction): void {
+  // Infer mutable ranges for non fields
+  inferMutableLifetimes(ir, false);
+
+  // Calculate aliases
+  const aliases = inferAliases(ir);
+  /*
+   * Calculate aliases for try/catch, where any value created
+   * in the try block could be aliased to the catch param
+   */
+  inferTryCatchAliases(ir, aliases);
+
+  /*
+   * Eagerly canonicalize so that if nothing changes we can bail out
+   * after a single iteration
+   */
+  let prevAliases: Map<Identifier, Identifier> = aliases.canonicalize();
+  while (true) {
+    // Infer mutable ranges for aliases that are not fields
+    inferMutableRangesForAlias(ir, aliases);
+
+    // Update aliasing information of fields
+    inferAliasForStores(ir, aliases);
+
+    // Update aliasing information of phis
+    inferAliasForPhis(ir, aliases);
+
+    const nextAliases = aliases.canonicalize();
+    if (areEqualMaps(prevAliases, nextAliases)) {
+      break;
+    }
+    prevAliases = nextAliases;
+  }
+
+  // Re-infer mutable ranges for all values
+  inferMutableLifetimes(ir, true);
+
+  /**
+   * The second inferMutableLifetimes() call updates mutable ranges
+   * of values to account for Store effects. Now we need to update
+   * all aliases of such values to extend their ranges as well. Note
+   * that the store only mutates the the directly aliased value and
+   * not any of its inner captured references. For example:
+   *
+   * ```
+   * let y;
+   * if (cond) {
+   *   y = [];
+   * } else {
+   *   y = [{}];
+   * }
+   * y.push(z);
+   * ```
+   *
+   * The Store effect from the `y.push` modifies the values that `y`
+   * directly aliases - the two arrays from the if/else branches -
+   * but does not modify values that `y` "contains" such as the
+   * object literal or `z`.
+   */
+  prevAliases = aliases.canonicalize();
+  while (true) {
+    inferMutableRangesForAlias(ir, aliases);
+    inferAliasForPhis(ir, aliases);
+    const nextAliases = aliases.canonicalize();
+    if (areEqualMaps(prevAliases, nextAliases)) {
+      break;
+    }
+    prevAliases = nextAliases;
+  }
+}
+
+function areEqualMaps<T>(a: Map<T, T>, b: Map<T, T>): boolean {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [key, value] of a) {
+    if (!b.has(key)) {
+      return false;
+    }
+    if (b.get(key) !== value) {
+      return false;
+    }
+  }
+  return true;
+}
--- a/Show More
+++ b/Show More