fix(vite-plugin-angular): keep nested class metadata in scope

setClassMetadata calls were appended at module scope, so a decorated
class nested in a function threw a ReferenceError in dev mode. Emit
them right after the class when it is not top-level.

parseOxc now falls back to the default transfer if raw transfer throws,
e.g. when its buffer cannot be allocated.

Author: claude

packages/vite-plugin-angular/src/lib/compiler/COMPILER.md

@@ -79,7 +79,7 @@ The existing vite-plugin-angular plugins (build optimizer, router, vitest, etc.)
 | `styles.ts`           | Style preprocessing via Vite's `preprocessCSS` (OXC-based extraction)                                                                                                          |
 | `type-elision.ts`     | OXC-based type-only import detection and elision (usage analysis, no type-checker needed)                                                                                      |
 | `constants.ts`        | Shared Angular name sets (`ANGULAR_DECORATORS`, `COMPILABLE_DECORATORS`, `FIELD_DECORATORS`, `SIGNAL_APIS`) — single source of truth to prevent drift                          |
-| `utils.ts`            | Type-only import detection (syntactic), class finder, `forwardRef` unwrapper (TS + OXC versions)                                                                               |
+| `utils.ts`            | `parseOxc` (raw-transfer parse with fallback), OXC class finder and walker, `forwardRef` unwrapper                                                                             |
 
 ## What's Supported
 

packages/vite-plugin-angular/src/lib/compiler/compile.spec.ts

@@ -40,11 +40,21 @@ describe('NgLite Compiler', () => {
       `export function setup() {
         @NgModule({ providers: [] })
         class TestModule {}
-        return TestModule;
+        @Component({ selector: 'x-nested', template: '<p>{{ v }}</p>' })
+        class Nested { v = input(0); }
+        return [TestModule, Nested];
       }`,
       'setup.ts',
     );
     expect(result).toContain('static ɵmod');
+    expect(result).toContain('static ɵcmp');
     expect(result).not.toContain('@NgModule');
+    // setClassMetadata references the class, so it must stay inside setup().
+    const scopeEnd = result.indexOf('return [TestModule, Nested]');
+    for (const cls of ['TestModule', 'Nested']) {
+      const idx = result.indexOf(`ɵsetClassMetadata(${cls},`);
+      expect(idx).toBeGreaterThan(-1);
+      expect(idx).toBeLessThan(scopeEnd);
+    }
   });
 });

packages/vite-plugin-angular/src/lib/compiler/compile.ts

@@ -345,8 +345,14 @@ export function compile(
     ivyCode: string[]; // "static ɵfac = ...", "static ɵcmp = ...", etc.
     decorators: any[]; // Angular decorators to remove (OXC nodes)
     classEnd: number; // Position of closing } in original source
+    // setClassMetadata calls for classes nested in a function scope, which
+    // must be emitted next to the class rather than at module scope.
+    scopedMetadata: o.Statement[];
   }
   const classResults: ClassCompileResult[] = [];
+  const topLevelClasses = new Set(
+    (oxcProgram.body as any[]).map((stmt) => toTopLevelStatement(stmt).decl),
+  );
   // Track synthetic imports needed for NgModule export expansion.
   // Maps exported class name → import specifier.
   const syntheticImports = new Map<string, string>();
@@ -1187,6 +1193,7 @@ export function compile(
       typeOnlyImports,
     );
     const propDecorators = buildPropDecorators(node, sourceCode, 'i0.');
+    const scopedMetadata: o.Statement[] = [];
     angularDecorators.forEach((dec) => {
       const decName = decoratorCallName(dec, sourceCode)!;
       const decArgsNode = dec.expression.arguments[0];
@@ -1283,9 +1290,12 @@ export function compile(
         const classMetadataExpr = isPartial
           ? compileDeclareClassMetadata(classMetaInput)
           : compileClassMetadata(classMetaInput);
-        constantPool.statements.push(
-          new o.ExpressionStatement(classMetadataExpr),
-        );
+        const metadataStmt = new o.ExpressionStatement(classMetadataExpr);
+        if (topLevelClasses.has(node)) {
+          constantPool.statements.push(metadataStmt);
+        } else {
+          scopedMetadata.push(metadataStmt);
+        }
       } catch (e) {
         // Skip if compileClassMetadata fails — surfaced via DEBUG=analog-fast-compile
         if (debugCompile.enabled) {
@@ -1315,6 +1325,7 @@ export function compile(
       ivyCode,
       decorators: [...angularDecorators, ...memberDecorators],
       classEnd: node.end,
+      scopedMetadata,
     });
   }
 
@@ -1439,6 +1450,10 @@ export function compile(
       const memberCode = cr.ivyCode.map((c) => '  ' + c + ';').join('\n');
       ms.appendLeft(cr.classEnd - 1, '\n' + memberCode + '\n');
     }
+
+    for (const stmt of cr.scopedMetadata) {
+      ms.appendLeft(cr.classEnd, `\n/*@__PURE__*/ ${emitAngularStmt(stmt)}`);
+    }
   }
 
   // 3. Emit constant pool statements.

packages/vite-plugin-angular/src/lib/compiler/utils.ts

@@ -8,13 +8,23 @@ import {
 
 // Raw transfer reads the AST straight from Rust memory instead of going
 // through JSON (~3x faster). Not yet in oxc-parser's published types.
-const parserOptions = {
-  experimentalRawTransfer: rawTransferSupported(),
-} as ParserOptions;
+const rawTransferOptions = { experimentalRawTransfer: true } as ParserOptions;
+let useRawTransfer = rawTransferSupported();
 
-/** Parse with oxc-parser, using raw transfer when the platform supports it. */
+/**
+ * Parse with oxc-parser, using raw transfer when the platform supports it.
+ * Falls back to the default transfer for this and later calls if raw
+ * transfer throws (e.g. its large buffer cannot be allocated).
+ */
 export function parseOxc(fileName: string, code: string): ParseResult {
-  return parseSync(fileName, code, parserOptions);
+  if (useRawTransfer) {
+    try {
+      return parseSync(fileName, code, rawTransferOptions);
+    } catch {
+      useRawTransfer = false;
+    }
+  }
+  return parseSync(fileName, code);
 }
 
 /** Recursively find all class declarations in an OXC AST, including nested scopes. */