fix: catch parameter alias handling and snapshot updates for noBackwardRangeExtension

.eslintrc.js

@@ -507,7 +507,6 @@ module.exports = {
         __IS_FIREFOX__: 'readonly',
         __IS_EDGE__: 'readonly',
         __IS_NATIVE__: 'readonly',
-        __IS_INTERNAL_MCP_BUILD__: 'readonly',
         __IS_INTERNAL_VERSION__: 'readonly',
         chrome: 'readonly',
       },

.github/workflows/runtime_eslint_plugin_e2e.yml

@@ -29,6 +29,7 @@ jobs:
           - "7"
           - "8"
           - "9"
+          - "10"
     steps:
       - uses: actions/checkout@v4
         with:

compiler/CLAUDE.md

@@ -35,6 +35,20 @@ yarn snap -p <file-basename> -d
 yarn snap -u
 ```
 
+## Linting
+
+```bash
+# Run lint on the compiler source
+yarn workspace babel-plugin-react-compiler lint
+```
+
+## Formatting
+
+```bash
+# Run prettier on all files (from the react root directory, not compiler/)
+yarn prettier-all
+```
+
 ## Compiling Arbitrary Files
 
 Use `yarn snap compile` to compile any file (not just fixtures) with the React Compiler:
@@ -215,12 +229,12 @@ const UseEffectEventHook = addHook(
 Feature flags are configured in `src/HIR/Environment.ts`, for example `enableJsxOutlining`. Test fixtures can override the active feature flags used for that fixture via a comment pragma on the first line of the fixture input, for example:
 
 ```javascript
-// enableJsxOutlining @enableChangeVariableCodegen:false
+// enableJsxOutlining @enableNameAnonymousFunctions:false
 
 ...code...
 ```
 
-Would enable the `enableJsxOutlining` feature and disable the `enableChangeVariableCodegen` feature.
+Would enable the `enableJsxOutlining` feature and disable the `enableNameAnonymousFunctions` feature.
 
 ## Debugging Tips
 
@@ -229,20 +243,19 @@ Would enable the `enableJsxOutlining` feature and disable the `enableChangeVaria
 3. Look for `Impure`, `Render`, `Capture` effects on instructions
 4. Check the pass ordering in Pipeline.ts to understand when effects are populated vs validated
 
-## Error Handling for Unsupported Features
+## Error Handling and Fault Tolerance
 
-When the compiler encounters an unsupported but known pattern, use `CompilerError.throwTodo()` instead of `CompilerError.invariant()`. Todo errors cause graceful bailouts in production; Invariant errors are hard failures indicating unexpected/invalid states.
+The compiler is fault-tolerant: it runs all passes and accumulates errors on the `Environment` rather than throwing on the first error. This lets users see all compilation errors at once.
 
-```typescript
-// Unsupported but expected pattern - graceful bailout
-CompilerError.throwTodo({
-  reason: `Support [description of unsupported feature]`,
-  loc: terminal.loc,
-});
-
-// Invariant is for truly unexpected/invalid states - hard failure
-CompilerError.invariant(false, {
-  reason: `Unexpected [thing]`,
-  loc: terminal.loc,
-});
-```
+**Recording errors** — Passes record errors via `env.recordError(diagnostic)`. Errors are accumulated on `Environment.#errors` and checked at the end of the pipeline via `env.hasErrors()` / `env.aggregateErrors()`.
+
+**`tryRecord()` wrapper** — In Pipeline.ts, validation passes are wrapped in `env.tryRecord(() => pass(hir))` which catches thrown `CompilerError`s (non-invariant) and records them. Infrastructure/transformation passes are NOT wrapped in `tryRecord()` because later passes depend on their output being structurally valid.
+
+**Error categories:**
+- `CompilerError.throwTodo()` — Unsupported but known pattern. Graceful bailout. Can be caught by `tryRecord()`.
+- `CompilerError.invariant()` — Truly unexpected/invalid state. Always throws immediately, never caught by `tryRecord()`.
+- Non-`CompilerError` exceptions — Always re-thrown.
+
+**Key files:** `Environment.ts` (`recordError`, `tryRecord`, `hasErrors`, `aggregateErrors`), `Pipeline.ts` (pass orchestration), `Program.ts` (`tryCompileFunction` handles the `Result`).
+
+**Test fixtures:** `__tests__/fixtures/compiler/fault-tolerance/` contains multi-error fixtures verifying all errors are reported.

compiler/apps/playground/__tests__/e2e/page.spec.ts

@@ -283,37 +283,6 @@ test('error is displayed when config has validation error', async ({page}) => {
   expect(output.replace(/\s+/g, ' ')).toContain('Unexpected compilationMode');
 });
 
-test('disableMemoizationForDebugging flag works as expected', async ({
-  page,
-}) => {
-  const store: Store = {
-    source: TEST_SOURCE,
-    config: `import type { PluginOptions } from 'babel-plugin-react-compiler/dist';
-
-({
-  environment: {
-    disableMemoizationForDebugging: true
-  }
-} satisfies PluginOptions);`,
-    showInternals: false,
-  };
-  const hash = encodeStore(store);
-  await page.goto(`/#${hash}`, {waitUntil: 'networkidle'});
-  await page.waitForFunction(isMonacoLoaded);
-  await expandConfigs(page);
-  await page.screenshot({
-    fullPage: true,
-    path: 'test-results/07-config-disableMemoizationForDebugging-flag.png',
-  });
-
-  const text =
-    (await page.locator('.monaco-editor-output').allInnerTexts()) ?? [];
-  const output = await formatPrint(text);
-
-  expect(output).not.toEqual('');
-  expect(output).toMatchSnapshot('disableMemoizationForDebugging-output.txt');
-});
-
 test('error is displayed when source has syntax error', async ({page}) => {
   const syntaxErrorSource = `function TestComponent(props) {
   const oops = props.

compiler/packages/babel-plugin-react-compiler/docs/passes/06-inferTypes.md

@@ -70,9 +70,6 @@ The `occursCheck` method prevents infinite types by detecting when a type variab
 - `DeclareContext` and `LoadContext` generate no type equations (intentionally untyped)
 - `StoreContext` with `Const` kind does propagate the rvalue type to enable ref inference through context variables
 
-### Event Handler Inference
-When `enableInferEventHandlers` is enabled, JSX props starting with "on" (e.g., `onClick`) on built-in DOM elements (excluding web components with hyphens) are inferred as `Function<BuiltInEventHandlerId>`.
-
 ## TODOs
 1. **Hook vs Function type ambiguity**:
    > "TODO: callee could be a hook or a function, so this type equation isn't correct. We should change Hook to a subtype of Function or change unifier logic."

compiler/packages/babel-plugin-react-compiler/docs/passes/31-codegenReactiveFunction.md

@@ -205,8 +205,6 @@ if ($[0] !== "source_hash_abc123") {
 }
 ```
 
-### Change Detection for Debugging
-When `enableChangeDetectionForDebugging` is configured, additional code is generated to detect when cached values unexpectedly change.
 
 ### Labeled Breaks
 Control flow with labeled breaks (for early returns or loop exits) uses `codegenLabel` to generate consistent label names:
@@ -231,7 +229,6 @@ type CodegenFunction = {
   prunedMemoBlocks: number;  // Scopes that were pruned
   prunedMemoValues: number;  // Values in pruned scopes
   hasInferredEffect: boolean;
-  hasFireRewrite: boolean;
 };
 ```