com.wallstop-studios.dxmessaging 3.0.1 → 3.1.0

package/CHANGELOG.md

@@ -7,6 +7,215 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.1.0]
+
+### Added
+
+- Deregistration-speed benchmarks (`DeregistrationFlood_1000Types_Cold` and
+  `DeregistrationFlood_1000Types_WarmJit`): the teardown mirror of the existing
+  registration floods. Each stages 1000 live registrations untimed, then times
+  `MessageRegistrationToken.UnregisterAll()` (the production deregistration path).
+  Both are wall-clock (latency) rows alongside the registration floods in the
+  rendered dispatch tables (closes the deregistration ask in GitHub issue #31).
+- `MessageAwareComponent.ReregisterOnEnableAfterRelease`: opt-in virtual property
+  (default `false`, preserving existing behavior). When overridden to return
+  `true`, a component whose registration token was released (for example via
+  `MessagingComponent.Release`) re-creates its token and replays
+  `RegisterMessageHandlers` the next time it is enabled, instead of staying
+  permanently unregistered. The replay runs exactly once per release; plain
+  enable/disable cycles without a release never re-stage registrations.
+
+### Changed
+
+- The Unity object identity backing `InstanceId` (the dispatch key) is now read
+  through a single version-gated source, `InstanceId.StableId`. On Unity 6.4+ it
+  uses the non-deprecated `EntityId.ToULong(...)` accessor and keeps its low 32
+  bits -- exactly the value the legacy `GetInstanceID()` returned (verified across
+  `GameObject`, `Component`, and `ScriptableObject`); older Unity keeps
+  `GetInstanceID()`. This keeps the package compiling on Unity 6.5+, where
+  `GetInstanceID()` becomes a compile error, and removes its deprecation warning on
+  Unity 6.4+. The 32-bit dispatch key, equality, and hashing are unchanged. Closes
+  GitHub issue #208.
+- `MessagingComponent.ToggleMessageHandler(false)` is no longer silently ignored
+  while `emitMessagesWhenDisabled` is true: explicit toggle calls now always win,
+  in both directions. Instead, the Unity enable/disable lifecycle itself now skips
+  the handler toggle while `emitMessagesWhenDisabled` is true, so disabling the
+  component still keeps emission alive (the flag's documented purpose) AND an
+  explicit `ToggleMessageHandler(false)` is no longer reverted by a later
+  enable/disable cycle. Previously the veto made explicit deactivation requests
+  silent no-ops and `OnEnable` force-reactivated the handler. One consequence:
+  setting the flag while the handler is lifecycle-deactivated (disabled with the
+  flag clear) means a later enable no longer auto-reactivates - call
+  `ToggleMessageHandler(true)` to resume.
+
+- Removed the internal per-handler dispatch-link machinery (the ten
+  `*DispatchLink` wrapper classes, their lazily-populated slot array, and
+  the outer-generation guard) plus the vestigial non-global prefreeze
+  descriptors that the flattened dispatch had already stopped consuming:
+  snapshots for non-global slots no longer build per-handler bucket entry
+  arrays at all (they dispatch exclusively through the resolved flat
+  delegate arrays and keep count-only buckets for the legacy "found any
+  handlers" reporting), which removes one pooled array rent/fill/return
+  per priority bucket from every snapshot rebuild. No public API or
+  dispatch semantics change (verified emission-for-emission against the
+  previous implementation, including global accept-all mid-emission
+  mutation ordering, trim-then-re-register staleness, reset-mid-dispatch,
+  and zero steady-state allocations).
+- Each emission now consults a cached per-(bus, message-type, kind) dispatch
+  plan instead of re-resolving interceptor, global accept-all, and
+  post-processor sinks with multiple type-cache lookups per emit. When the
+  plan shows none of those features are present (the common case), a fast
+  emit lane runs only the handle phase: one plan fetch, one validity check,
+  snapshot acquisition, and the flat dispatch loop. Plans are invalidated by
+  a single bus-wide version stamp that every registration, deregistration,
+  interceptor/global/post mutation, sweep/Trim, `ResetState`, and runtime
+  settings reload bumps; mutations performed by handlers mid-emission are
+  re-detected at phase boundaries, so frozen-snapshot semantics, mid-emission
+  registration gating, interceptor re-targeting, and mid-dispatch reset
+  behavior are unchanged (verified emission-for-emission against the previous
+  implementation). Diagnostics mode and `MessagingDebug.enabled` are still
+  read live on every emission. Out-of-Unity rig measurements (directional):
+  one-handler throughput up roughly 1.5-1.7x per kind and four-handler
+  fan-out up ~35%, with feature-heavy paths unchanged within noise and zero
+  steady-state allocations.
+- The internal flat-dispatch shape assertion (`DebugAssertFlatShape`) moved
+  from `DEBUG` builds to the opt-in `DXMESSAGING_INTERNAL_CHECKS` scripting
+  define; it cost a type test per dispatch on Editor hot paths.
+- On IL2CPP players, the dispatch hot loops (flat snapshot walks, global
+  accept-all bucket walks, and global entry invokers) now opt out of the
+  generated per-iteration null and array-bounds checks via a vendored
+  internal `Unity.IL2CPP.CompilerServices.Il2CppSetOptionAttribute`. The
+  elided checks guard invariants the snapshot builder already guarantees
+  (frozen arrays, non-null handler/invoker pairs, `count` never exceeding
+  the array length), all pinned by tests; rig/diagnostic builds keep the
+  `DXMESSAGING_INTERNAL_CHECKS` shape assertions. No behavior change under
+  Mono or in the editor.
+- On IL2CPP players, the per-emit AOT untyped-dispatch bridge registration
+  (`EnsureAot*Bridge<T>`, IL2CPP-only) now runs when a message type's dispatch
+  plan is first built on a bus (the first typed emit) instead of on every emit,
+  removing a generic-static class-initialization check and a non-inlined call
+  from the steady-state IL2CPP dispatch prologue. The registration is latched
+  process-globally, so it actually executes once per type; the guarded call site
+  is simply reached at first plan build rather than on every emit. The bridge is
+  rooted before the first untyped dispatch of a type by either any registration
+  of that type or its first typed emit, so the untyped-dispatch contract is
+  unchanged (a never-touched type still throws the same missing-bridge error).
+  No behavior change under Mono or in the editor (the calls compile out there).
+- Dispatch for every message kind (untargeted, targeted, and broadcast;
+  handle and post-process phases) now resolves handlers to flat, pooled
+  delegate arrays at snapshot-build time instead of walking per-handler
+  dictionaries and dispatch links per message. Measured on Editor PlayMode
+  Mono x64 versus the previous release: one untargeted handler 17.5M to
+  22.1M emits/sec, four untargeted handlers 3.9M to 20.0M, one targeted
+  listener 11.4M to 15.7M, sixteen targeted listeners 0.73M to 8.7M, one
+  broadcast handler 8.0M to 15.6M, four post-processors 3.3M to 12.6M -
+  all with zero steady-state allocations, an 8% faster cold registration
+  flood, and unchanged dispatch semantics (snapshot freezing, priority and
+  registration order, mid-emission registration visibility). One deliberate
+  refinement: a handler that deactivates itself mid-emission now skips its
+  own remaining delegates in that emission for every kind (the active check
+  runs per delegate instead of once per handler), matching the documented
+  immediate-deactivation semantics. Mid-emission registration gating is
+  also now uniform: a delegate registered during an emission never fires in
+  that emission, for every kind and every registration shape. Previously a
+  handler registering a different-shaped delegate for the same type on its
+  own MessageHandler could fire it in the same emission, depending on
+  unrelated handler counts.
+
+### Fixed
+
+- Domain-reload advisory warnings are now re-evaluated after deferred Editor
+  settings creation/migration, so an initial passive load with no settings asset
+  cannot permanently skip an unsuppressed warning for that editor domain.
+- Token cleanup now clears token-local diagnostics and stale teardown state:
+  `UnregisterAll()`, `Dispose()`, final-handle removal, released
+  `MessagingComponent` tokens, and disposed registration leases no longer
+  retain metadata, call counts, emission history, or stale deregistration
+  closures that could report old registrations or over-deregister later.
+  Failed `Enable()` replays now roll back partial registrations before
+  throwing the original failure; failed active `RetargetMessageBus()` replays
+  roll back partial new-bus registrations and restore previous-bus
+  registrations that are not still live behind a failed rollback cleanup.
+  Deregistration actions that throw before cleanup remain retryable instead
+  of being forgotten, including through owning registration leases and
+  `MessagingComponent.Release()` retries. `ActivateOnBuild` failures now
+  clean up the partially built lease before throwing again; if cleanup cannot
+  complete, `MessageRegistrationBuildException` exposes the retryable lease
+  so callers can dispose it after resolving the cleanup failure.
+- Interceptors registered through a `MessageRegistrationToken` bound to a
+  custom bus (`MessageRegistrationToken.Create(handler, customBus)`) now land
+  on that bus. `RegisterUntargetedInterceptor`, `RegisterTargetedInterceptor`,
+  and `RegisterBroadcastInterceptor` previously dropped the token's bus and
+  registered on the handler's default (typically global) bus, so they never
+  saw custom-bus emissions and silently intercepted global traffic instead.
+  The fix also covers registrations staged while disabled (they activate on
+  the token's bus at `Enable()` time) and `RetargetMessageBus`, which now
+  re-routes interceptors along with every other registration kind.
+- Registering or deregistering a handler mid-emission and then emitting the
+  same message type reentrant-style from inside a handler no longer corrupts
+  the in-flight dispatch.
+  The nested emission's snapshot rebuild previously released the pooled
+  arrays the outer emission was still iterating
+  (`NullReferenceException` / `ArgumentOutOfRangeException`, or silent
+  cross-dispatch aliasing at deeper nesting). Displaced snapshots are now
+  released only after the outermost dispatch exits, each emission keeps its
+  own frozen-cache identity across nested emissions, and the broadcast
+  priority walk tolerates nested membership churn.
+- A `MessageRegistrationLease` whose `OnActivate` callback throws no longer
+  wedges its registrations. The lease previously recorded itself as inactive
+  while the registrations stayed live, so `Deactivate()` and `Dispose()`
+  silently refused to release them. The lease now marks itself active before
+  invoking the callback: the exception still propagates, and standard
+  `Deactivate()`/`Dispose()` teardown fully releases the registrations.
+- Calling `DxMessagingStaticState.Reset` (or resetting a bus) from inside a
+  message handler no longer crashes the in-flight emission. Targeted and
+  broadcast dispatch previously returned the active emission's pooled snapshot
+  arrays mid-iteration (`NullReferenceException` /
+  `ArgumentOutOfRangeException`); the teardown is now deferred until the
+  outermost dispatch exits, mirroring the existing `Trim` deferral, and the
+  remaining handlers in that emission short-circuit cleanly.
+- Equal-priority handlers now always dispatch in live registration order. The
+  documented "same priority uses registration order" contract previously broke
+  after remove/re-register churn (a new handler could dispatch in a removed
+  handler's old position), after `Disable()`/`Enable()` cycles (replay order
+  permuted), and across components (a newly created component could dispatch
+  in a destroyed component's old position). Handler caches, bus-side priority
+  buckets, and token replay now preserve insertion order explicitly.
+- Targeted and broadcast post-processors now follow an interceptor-rewritten
+  target/source. When an interceptor redirects a message via its
+  `ref InstanceId` parameter, post-processors registered for the rewritten id
+  run (previously the broadcast path never re-resolved the rewritten source,
+  and the targeted path preferred a stale pre-interceptor snapshot, so the
+  rewritten id's post-processors were silently skipped).
+- `DiagnosticsTarget` gating now matches its documented semantics. Player
+  builds previously enabled diagnostics for the `Editor` flag and ignored the
+  `Runtime` flag, and the Editor enabled diagnostics when only `Runtime` was
+  set. `Editor` now enables diagnostics only inside the Unity Editor,
+  `Runtime` only in player/runtime builds, and `All` in both, exactly as the
+  diagnostics guide describes.
+- Analyzer payload builds are now reproducible under the pinned
+  `SourceGenerators/global.json` SDK. The shipped analyzer and source-generator
+  DLLs no longer embed source revision or PDB metadata, CI double-builds them
+  into temporary payload directories before comparing against
+  `Editor/Analyzers`, and Unity runner maintenance now verifies or repairs the
+  full active editor matrix outside ordinary test jobs.
+- IL2CPP builds now root untyped dispatch bridges for concrete
+  source-visible message types without changing the public API. The source
+  generator emits IL2CPP-only AOT bridge registration for attributed messages
+  and manual `IUntargetedMessage` / `ITargetedMessage` /
+  `IBroadcastMessage` implementations, while open generic definitions are
+  skipped until a closed generic type is used through the typed registration
+  path. Untyped dispatch also keeps separate per-kind delegate caches, so a
+  message type that participates in more than one dispatch kind can no longer
+  reuse the wrong cached delegate shape.
+- Unity projects no longer keep stale DxMessaging analyzer entries in `csc.rsp`; the setup script removes package-cache analyzer registrations so Unity loads the shipped analyzer and source generator once through the `RoslynAnalyzer`-labeled plugin copy. The base-call ignore sidecar's `-additionalfile:` entry is also re-synchronized after deferred sidecar regeneration, so first-load `OnValidate` writes and Inspector ignore-list edits repair missing `csc.rsp` wiring during the same editor session.
+- Provider-backed emit helpers now route sourced, targeted, and untargeted messages through the resolved `IMessageBus`, so custom bus and DI-provider callers no longer fall back to the global bus for interface-shaped message dispatch.
+- Standalone and IL2CPP player builds now compile. The dispatch hot path performs reinterpret casts that previously used `System.Runtime.CompilerServices.Unsafe`; the Unity Editor supplies that type, but player builds under the .NET Standard 2.0 profile do not, so editmode and playmode passed while standalone IL2CPP failed to build with `CS0103: The name 'Unsafe' does not exist in the current context`. Those calls now route through Unity's built-in `UnsafeUtility` (in `UnityEngine.CoreModule`), which resolves identically in the Editor and every player scripting backend. The change preserves the existing zero-allocation dispatch behavior and adds no package dependency or shipped assembly.
+- Shipped source generators now compile against Unity 2021-compatible Roslyn 3.8 APIs and use the classic `ISourceGenerator` entry point, preventing Unity 2021.3 analyzer-host load failures (`CS8032`) while preserving the generated message-id and auto-constructor output for newer Unity editors.
+- `MessageRegistrationToken.RemoveRegistration(handle)` now compiles cleanly on Unity 2021 while preserving the existing behavior of removing the active deregistration, staged registration, metadata, and diagnostic call-count entries.
+- Unity 2021.3 no longer aborts compilation with _Multiple precompiled assemblies with the same name_ (`PrecompiledAssemblyException`). The shipped Roslyn analyzer and source-generator DLLs are now excluded from every build platform (the Editor included) and activated solely by the `RoslynAnalyzer` asset label, so Unity treats them as compiler analyzers rather than managed precompiled assemblies that collide with the copy placed in the consuming project's `Assets/`. Generated message-id and auto-constructor output is unchanged.
+- The dependency-injection sample README (`Samples~/DI`) now links to the real `Runtime/Unity/Integrations/VContainer/VContainerRegistrationExtensions.cs`; the previous link dropped the `VContainer/` folder and resolved to a missing file.
+
 ## [3.0.1]
 
 ### Added
@@ -44,7 +253,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `RegisterGlobalAcceptAll` (`HandleGlobalUntargeted`/`HandleGlobalTargeted`/`HandleGlobalBroadcast`) is intentionally NOT covered by this fix. The bus's global accept-all dispatch path prefreezes lazily per-entry inside the dispatch loop, so a sibling `MessageHandler` that removes another's global registration mid-emit causes the removed handler to be skipped on the in-flight emission. The behavior is pinned by `MutationPostProcessorAcrossHandlersTests.RemoveOtherGlobalAcceptAllAcrossHandlersDuringDispatch`; if a future change introduces upfront global-handler prefreeze, that test must be updated to expect the snapshot semantics that the per-kind paths already provide.
 - `DxMessagingStaticState.Reset` is now race-safe against deferred deregistrations. Previously, when a message-aware component was destroyed but its disable callback had not yet run (Unity defers Object.Destroy to end of frame) and Reset ran in between, the deferred token teardown would log spurious "Received over-deregistration of {type} for {handler}" errors against the user's Unity console. The bus now stamps each captured deregister closure with a generation counter and silently no-ops closures captured before a Reset. Applied uniformly across every register entry point (untargeted, targeted, broadcast, GlobalAcceptAll, and all three interceptor kinds). The same race-safety guarantee is now propagated to user-installed custom global buses via `MessageBus.BumpResetGeneration()`, which `DxMessagingStaticState.Reset` invokes on the active global bus when it differs from the built-in default; the custom bus's sinks are intentionally left intact to avoid clobbering state the user installed it to preserve. User code is unaffected except that previously-spurious error logs disappear.
 - `MessageRegistrationToken.RemoveRegistration(handle)` no longer leaks the staged registration entry, so a `Disable()`/`Enable()` cycle after `RemoveRegistration` no longer silently re-registers the removed handler. The fix also drops the matching metadata and call-count entries so diagnostic mode does not accumulate stale handles.
-- Resolved [issue #204](https://github.com/wallstop/DxMessaging/issues/204) (build artifacts and orphaned `.meta` files leaking into the npm tarball) and prevented its regression: `scripts/validate-npm-meta.js` now runs `validateNoBuildArtifactsInTarball` (rejects `bin/`, `obj/`, `*.pdb`, `*.tmp`, `*.csproj.user`, `.vs/`, `.idea/`, `*.suo`, and `*.DotSettings.user` paths in the tarball) and `validatePublishedFilesArePairedWithMetas` (every shipped Unity-relevant file has its `.meta` neighbour and every shipped directory has its directory `.meta`), wired into `prepack` and the `validate-npm-meta` workflow so the next publish cannot reintroduce the regression.
+- Resolved [issue #204](https://github.com/Ambiguous-Interactive/DxMessaging/issues/204) (build artifacts and orphaned `.meta` files leaking into the npm tarball) and prevented its regression: `scripts/validate-npm-meta.js` validates real `npm pack --json --dry-run --ignore-scripts` output (and release tarballs via `--tarball`) by rejecting `bin/`, `obj/`, `*.pdb`, `*.tmp`, `*.csproj.user`, `.vs/`, `.idea/`, `*.suo`, `*.user`, and `*.DotSettings.user` paths, while enforcing `.meta` pairing for shipped Unity files and directories. The guard now runs in `validate:all`, pre-push hooks, and the release workflow.
 
 ## [2.2.0]
 
@@ -90,7 +299,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Wiki synchronization workflow that automatically syncs documentation to GitHub Wiki
 - Documentation validation workflow that runs on pull requests and pushes
 - MkDocs build validation in pre-push hooks
-- Searchable documentation site at <https://wallstop.github.io/DxMessaging/>
+- Searchable documentation site at <https://ambiguous-interactive.github.io/DxMessaging/>
 - Theme-aware Mermaid diagrams with automatic light/dark mode switching for GitHub Pages
 - User-visible error messages when Mermaid diagrams fail to render
 

package/Editor/Analyzers/DxMessagingConsoleHarvester.cs

@@ -340,10 +340,11 @@ namespace DxMessaging.Editor.Analyzers
 
                 LoadFromDisk();
 
-                // AssetDatabase isn't fully ready inside the static ctor; defer the first scan one
-                // editor tick so settings load doesn't fight a transitional asset-import state.
-                EditorApplication.delayCall += SafeRescanFromCallback;
-                AssemblyReloadEvents.afterAssemblyReload += SafeRescanFromCallback;
+                // AssetDatabase isn't fully ready inside the static ctor; defer the first scan
+                // until Unity is idle so settings load doesn't fight a transitional asset-import
+                // state.
+                ScheduleRescanWhenIdle();
+                AssemblyReloadEvents.afterAssemblyReload += ScheduleRescanWhenIdle;
                 CompilationPipeline.assemblyCompilationFinished += OnAssemblyCompilationFinished;
                 if (!_logEntriesDisabled)
                 {
@@ -352,8 +353,9 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                Debug.LogWarning(
-                    $"[DxMessaging] DxMessagingConsoleHarvester failed to initialize: {ex.Message}"
+                DxMessagingEditorLog.LogWarning(
+                    "DxMessagingConsoleHarvester failed to initialize.",
+                    ex
                 );
                 _logEntriesDisabled = true;
                 IsAvailable = false;
@@ -428,7 +430,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("scanner", $"BaseCallTypeScanner.Scan threw: {ex.Message}");
+                LogExceptionOnce("scanner", "BaseCallTypeScanner.Scan threw.", ex);
                 scannerEntries = new Dictionary<string, BaseCallReportEntry>(
                     StringComparer.Ordinal
                 );
@@ -492,7 +494,7 @@ namespace DxMessaging.Editor.Analyzers
                 }
                 catch (Exception ex)
                 {
-                    LogOnce("aggregate", $"Snapshot merge failed: {ex.Message}");
+                    LogExceptionOnce("aggregate", "Snapshot merge failed.", ex);
                     // Fall through with the scanner-only snapshot; partial data is better than
                     // wiping the snapshot when the bridge half misbehaves.
                 }
@@ -616,7 +618,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("getcount", $"GetCount invocation failed: {ex.Message}");
+                LogExceptionOnce("getcount", "GetCount invocation failed.", ex);
                 return new Dictionary<string, ParsedTypeReport>(StringComparer.Ordinal);
             }
 
@@ -633,7 +635,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("start", $"StartGettingEntries invocation failed: {ex.Message}");
+                LogExceptionOnce("start", "StartGettingEntries invocation failed.", ex);
                 return new Dictionary<string, ParsedTypeReport>(StringComparer.Ordinal);
             }
 
@@ -652,8 +654,13 @@ namespace DxMessaging.Editor.Analyzers
                     {
                         harvestedCount = (int)_getCount.Invoke(null, null);
                     }
-                    catch
+                    catch (Exception ex)
                     {
+                        LogExceptionOnce(
+                            "getcount-after-start",
+                            "GetCount after StartGettingEntries failed.",
+                            ex
+                        );
                         // Retain the previous count.
                     }
                 }
@@ -670,9 +677,10 @@ namespace DxMessaging.Editor.Analyzers
                     }
                     catch (Exception ex)
                     {
-                        LogOnce(
+                        LogExceptionOnce(
                             "getentry",
-                            $"GetEntryInternal invocation failed at index {j}: {ex.Message}"
+                            $"GetEntryInternal invocation failed at index {j}.",
+                            ex
                         );
                         continue;
                     }
@@ -684,9 +692,10 @@ namespace DxMessaging.Editor.Analyzers
                     }
                     catch (Exception ex)
                     {
-                        LogOnce(
+                        LogExceptionOnce(
                             "getmessage",
-                            $"LogEntry.message read failed at index {j}: {ex.Message}"
+                            $"LogEntry.message read failed at index {j}.",
+                            ex
                         );
                         continue;
                     }
@@ -699,7 +708,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("harvest", $"Harvest loop failed: {ex.Message}");
+                LogExceptionOnce("harvest", "Harvest loop failed.", ex);
             }
             finally
             {
@@ -709,7 +718,7 @@ namespace DxMessaging.Editor.Analyzers
                 }
                 catch (Exception ex)
                 {
-                    LogOnce("end", $"EndGettingEntries invocation failed: {ex.Message}");
+                    LogExceptionOnce("end", "EndGettingEntries invocation failed.", ex);
                 }
             }
 
@@ -720,9 +729,10 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce(
+                LogExceptionOnce(
                     "aggregate-logentries",
-                    $"Aggregating LogEntries lines failed: {ex.Message}"
+                    "Aggregating LogEntries lines failed.",
+                    ex
                 );
                 return new Dictionary<string, ParsedTypeReport>(StringComparer.Ordinal);
             }
@@ -770,11 +780,7 @@ namespace DxMessaging.Editor.Analyzers
             // LogEntries is unavailable, Tick is not registered, so we fall back to delayCall.
             if (_logEntriesDisabled)
             {
-                if (!_rescanScheduled)
-                {
-                    _rescanScheduled = true;
-                    EditorApplication.delayCall += DrainScheduledRescan;
-                }
+                ScheduleRescanWhenIdle();
                 return;
             }
             _lastSeenCount = -1;
@@ -816,7 +822,7 @@ namespace DxMessaging.Editor.Analyzers
                 }
                 catch (Exception ex)
                 {
-                    LogOnce("tick-count", $"GetCount during Tick failed: {ex.Message}");
+                    LogExceptionOnce("tick-count", "GetCount during Tick failed.", ex);
                     return;
                 }
 
@@ -827,7 +833,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("tick", $"Tick failed: {ex.Message}");
+                LogExceptionOnce("tick", "Tick failed.", ex);
             }
         }
 
@@ -841,27 +847,13 @@ namespace DxMessaging.Editor.Analyzers
             // are still compiling; the compiler holds its log-buffer lock and our reflection
             // call blocks waiting for it. Combined with AssetDatabase touches inside RescanNow,
             // this caused permanent script-compilation freezes on Unity startup.
-            //
-            // S4: when the legacy console-bridge is OFF, we don't need to parse CompilerMessage
-            // payloads at all; the IL-reflection scanner is the sole data source and it runs
-            // off the AssemblyReloadEvents.afterAssemblyReload hook that fires once per build,
-            // not per-assembly. Bail out early so a 30-assembly build doesn't burn CPU running
-            // the regex-heavy parser 30 times for output we'll never read. Read the setting once
-            // up-front so the gate decision is consistent for the whole callback (settings can
-            // be edited concurrently by the Project Settings page on the main thread).
-            DxMessagingSettings settingsForGate = TryLoadSettings();
-            bool bridgeEnabled = settingsForGate != null && settingsForGate._useConsoleBridge;
-            if (!bridgeEnabled)
-            {
-                return;
-            }
-
             // We DO parse the per-assembly CompilerMessage payload here (cheap, pure-CPU work,
-            // no AssetDatabase / LogEntries contact) and stash it in the cross-thread channel.
-            // DrainScheduledRescan (on a delayCall) folds the channel into the live snapshot
-            // once the compile burst is complete. This is the primary data path on Unity 2021,
-            // where Roslyn-analyzer warnings DO arrive in CompilerMessage[] but do NOT reliably
-            // appear in the LogEntries store.
+            // no AssetDatabase / LogEntries contact) and stash it in the cross-thread channel
+            // without checking settings here. The settings gate requires AssetDatabase access, so
+            // RescanNow applies it later after DrainScheduledRescan has requeued until Unity is
+            // idle; if the bridge is disabled, RescanNow clears this pending buffer. This is the
+            // primary bridge data path on Unity 2021, where Roslyn-analyzer warnings DO arrive in
+            // CompilerMessage[] but do NOT reliably appear in the LogEntries store.
             try
             {
                 if (!string.IsNullOrEmpty(assemblyPath) && messages != null)
@@ -899,17 +891,21 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce(
+                LogExceptionOnce(
                     "compilation-parse",
-                    $"Failed to parse CompilerMessage payload for {assemblyPath}: {ex.Message}"
+                    $"Failed to parse CompilerMessage payload for {assemblyPath}.",
+                    ex
                 );
             }
 
-            // Fix: schedule a single delayCall. delayCall fires AFTER the current event chain
-            // unwinds and AFTER `EditorApplication.isCompiling` flips back to false. Multiple
-            // delayCall registrations from the same compile burst are debounced by the
-            // _rescanScheduled latch; only one deferred RescanNow runs per build.
-            if (_rescanScheduled)
+            // Schedule a single delayed drain. The callback rechecks editor state and requeues if
+            // Unity is still compiling/updating, so this never drops the final rescan.
+            ScheduleRescanWhenIdle();
+        }
+
+        internal static void ScheduleRescanWhenIdle()
+        {
+            if (!IsAvailable || _rescanScheduled)
             {
                 return;
             }
@@ -942,7 +938,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("rescan-callback", $"RescanNow callback threw: {ex.Message}");
+                LogExceptionOnce("rescan-callback", "RescanNow callback threw.", ex);
             }
         }
 
@@ -971,7 +967,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("settings", $"Could not load DxMessagingSettings: {ex.Message}");
+                LogExceptionOnce("settings", "Could not load DxMessagingSettings.", ex);
                 return null;
             }
         }
@@ -984,9 +980,10 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce(
+                LogExceptionOnce(
                     $"resolve-{name}",
-                    $"Failed to resolve static method '{name}' on {type.FullName}: {ex.Message}"
+                    $"Failed to resolve static method '{name}' on {type.FullName}.",
+                    ex
                 );
                 return null;
             }
@@ -1000,9 +997,10 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce(
+                LogExceptionOnce(
                     $"resolve-field-{name}",
-                    $"Failed to resolve instance field '{name}' on {type.FullName}: {ex.Message}"
+                    $"Failed to resolve instance field '{name}' on {type.FullName}.",
+                    ex
                 );
                 return null;
             }
@@ -1017,6 +1015,15 @@ namespace DxMessaging.Editor.Analyzers
             Debug.LogWarning($"[DxMessaging] {message}");
         }
 
+        private static void LogExceptionOnce(string key, string message, Exception exception)
+        {
+            if (!AlreadyWarned.Add(key))
+            {
+                return;
+            }
+            DxMessagingEditorLog.LogWarning(message, exception);
+        }
+
         private static void RaiseReportUpdated()
         {
             try
@@ -1025,7 +1032,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                Debug.LogWarning($"[DxMessaging] ReportUpdated subscriber threw: {ex.Message}");
+                LogExceptionOnce("report-updated", "ReportUpdated subscriber threw.", ex);
             }
         }
 
@@ -1057,7 +1064,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("persist", $"Failed to persist analyzer diagnostics report: {ex.Message}");
+                LogExceptionOnce("persist", "Failed to persist analyzer diagnostics report.", ex);
             }
         }
 
@@ -1097,7 +1104,7 @@ namespace DxMessaging.Editor.Analyzers
             }
             catch (Exception ex)
             {
-                LogOnce("load", $"Failed to load analyzer diagnostics report: {ex.Message}");
+                LogExceptionOnce("load", "Failed to load analyzer diagnostics report.", ex);
             }
         }
 

package/Editor/Analyzers/Microsoft.CodeAnalysis.CSharp.dll.meta

@@ -16,21 +16,21 @@ PluginImporter:
     second:
       enabled: 0
       settings:
-        Exclude Editor: 0
+        Exclude Editor: 1
         Exclude Linux64: 1
         Exclude OSXUniversal: 1
         Exclude WebGL: 1
         Exclude Win: 1
         Exclude Win64: 1
   - first:
-      Any: 
+      Any:
     second:
       enabled: 0
       settings: {}
   - first:
       Editor: Editor
     second:
-      enabled: 1
+      enabled: 0
       settings:
         DefaultValueInitialized: true
   - first:

package/Editor/Analyzers/Microsoft.CodeAnalysis.dll.meta

@@ -16,21 +16,21 @@ PluginImporter:
     second:
       enabled: 0
       settings:
-        Exclude Editor: 0
+        Exclude Editor: 1
         Exclude Linux64: 1
         Exclude OSXUniversal: 1
         Exclude WebGL: 1
         Exclude Win: 1
         Exclude Win64: 1
   - first:
-      Any: 
+      Any:
     second:
       enabled: 0
       settings: {}
   - first:
       Editor: Editor
     second:
-      enabled: 1
+      enabled: 0
       settings:
         DefaultValueInitialized: true
   - first:

package/Editor/Analyzers/System.Collections.Immutable.dll.meta

@@ -16,21 +16,21 @@ PluginImporter:
     second:
       enabled: 0
       settings:
-        Exclude Editor: 0
+        Exclude Editor: 1
         Exclude Linux64: 1
         Exclude OSXUniversal: 1
         Exclude WebGL: 1
         Exclude Win: 1
         Exclude Win64: 1
   - first:
-      Any: 
+      Any:
     second:
       enabled: 0
       settings: {}
   - first:
       Editor: Editor
     second:
-      enabled: 1
+      enabled: 0
       settings:
         DefaultValueInitialized: true
   - first:

package/Editor/Analyzers/System.Reflection.Metadata.dll.meta

@@ -16,21 +16,21 @@ PluginImporter:
     second:
       enabled: 0
       settings:
-        Exclude Editor: 0
+        Exclude Editor: 1
         Exclude Linux64: 1
         Exclude OSXUniversal: 1
         Exclude WebGL: 1
         Exclude Win: 1
         Exclude Win64: 1
   - first:
-      Any: 
+      Any:
     second:
       enabled: 0
       settings: {}
   - first:
       Editor: Editor
     second:
-      enabled: 1
+      enabled: 0
       settings:
         DefaultValueInitialized: true
   - first: