transform_ts_enum rewrites enum E { … } into var/let E = (function(E) { … })(E || {}) but left the semantic table describing the old shape:

• the enum's symbol still carried RegularEnum/ConstEnum flags, even though the binding now backs a plain var/let;
• the function-expression body scope (re-used from the enum body) had default scope flags instead of Function;
• member names (Up, Down, …) remained bound in that scope despite living on the runtime enum object now, not as JS-level bindings.

TransformerReturn exposes this scoping table, so downstream consumers — oxc_minifier, the mangler, NAPI clients — were reading a model that no longer described the emitted code. The transform-checker conformance suite was snapshotting this as ~20 fixtures' worth of Bindings mismatch / Symbol flags mismatch / Scope flags mismatch errors (optimize-enums/typeof-kept, exported-not-removed, and the new const-enum-*-kept fixtures from the parent PR).

Fix

Sync the scoping table when lowering happens:

• set the symbol's flags to FunctionScopedVariable / BlockScopedVariable based on var vs let;
• add ScopeFlags::Function to the body scope;
• drop enum-member bindings from that scope.

Skip the is_already_declared (enum-merge) path's symbol-flag update, since that path reuses an existing outer binding.

Identifying members by their EnumMember symbol flag (rather than by name) naturally handles enum y { y = 123 }: the IIFE param's binding has overwritten the member's entry under that name, so its symbol is no longer reachable via get_bindings, and the param's FunctionScopedVariable symbol survives untouched.

Why the updates are queued and drained per scope

transform_ts_enum runs in enter_statement (before sibling references are visited) when the enum can't be fully removed — e.g. enum Mixed { A = "hello", B } (B's auto-increment after a string isn't statically evaluable), or export enum E { … }. Rewriting the symbol flags eagerly there would make the inliner later see FunctionScopedVariable for sibling Mixed.A / Direction.Up references, fail the is_const_enum / RegularEnum check, and skip inlining.

Queue the updates on TypeScriptEnum.pending_scoping_updates with each enum's enclosing_scope_id, and drain them in exit_statements for that scope. By the time exit_statements fires for the enclosing scope, the entire subtree (where any reference to the enum could live) has been visited depth-first, so every enter_expression that could inline an E.X access has already run.

The flush runs unconditionally because transform_ts_enum is invoked unconditionally for exported enums regardless of the optimize_* flags; the optimize-gated loop in exit_statements only deals with deferred-removable enums.

Impact

Pass count: 236 → 246 (oxc.snap.md) and 700 → 711 (babel.snap.md); ~19 fixtures move from semantic-mismatch failures to passing, plus 2 more (optimize-enums/auto-increment-after-string, optimize-enums/exported-not-removed) that the deferred-update approach unblocks. ~660 lines of snapshot errors removed.