Fix sidebar workspace frame collection virtualization

[austinywang]

Fixes #5323.

Reproduce-first evidence

I reproduced the mechanism locally before changing code, using the existing production cmux process on this machine rather than a fresh VM or a new dev build.

Observed:

• The active cmux window has 128 workspaces, enough to exercise the 100+ workspace scale called out in the issue.
• The running production app did not expose debug.sidebar.simulate_drag, so I used ARM-native Time Profiler sampling while applying harmless temporary UserDefaults churn, then deleted the temporary key.
• Trace: /tmp/cmux-issue5323-before-arm64.trace.
• The exported time profile showed UserDefaultsSettingsStore notification handling re-entering VerticalTabsSidebar.body / VerticalTabsSidebar.workspaceRows, then SwiftUI preference/layout work including GraphHost.updatePreferences, NSHostingView.layout, ForEachList.applyNodes, and DynamicContainerInfo.updateItems.
• The same trace includes GeometryProxy.subscript.getter from VerticalTabsSidebar.workspaceRows(renderContext:), which is the sidebar drop overlay resolving per-row .bounds anchors into drop target frames.

Expected:

• In steady state, with no sidebar drag and no Bonsplit workspace drop active, rows should not publish per-row .bounds anchors and the sidebar should not install the row-frame overlayPreferenceValue / GeometryReader reader. A LazyVStack can then avoid requiring off-viewport row frames.

Fix

• Added a shared policy seam, SidebarDropPlanner.shouldCollectWorkspaceDropTargets(...), with a failing test committed first (test: reproduce sidebar drop target collection bug).
• Gated every SidebarWorkspaceRowFramePreferenceKey emitter for workspace rows and group headers.
• Gated the sidebar-wide overlayPreferenceValue(SidebarWorkspaceRowFramePreferenceKey.self) so it is only installed while workspace drop target collection is active.
• Kept a lightweight AppKit Bonsplit drag-capture overlay at rest without any row-frame preference reader, so Bonsplit drags can still request collection.
• Scoped deferred Bonsplit drops to the active target-collection request and deferred pending-drop replay out of updateNSView to avoid mutating SwiftUI bindings during the representable update pass.
• Preserved existing row content optimizations; this does not re-blame TabItemView body work.

Before / after verification

Before:

• Runtime trace on the 128-workspace local app showed defaults writes reaching the sidebar row preference/layout path and resolving row anchors through GeometryProxy.subscript.
• The first commit's policy implementation intentionally returns true for no active drag, matching the old always-on collection behavior; the new test is red against that commit.

After:

• The fix changes the no-drag policy to false; row/group .bounds anchors and the row-frame overlayPreferenceValue reader are absent in steady state.
• The policy returns true during a sidebar workspace drag or a detected Bonsplit workspace drop, limiting all-row frame collection to actual drag sessions.
• I did not run a local dev build or runtime after-profile because the task explicitly forbids reload.sh/builds before CI is green and user authorization is given.

Tests / checks

• Added coverage in cmuxTests/SidebarWorkspaceDropPlannerTests.swift for:
  • no drag => target collection disabled
  • sidebar drag => target collection enabled
  • Bonsplit workspace drop => target collection enabled
• Addressed Cursor Bugbot and CodeRabbit review comments around pending Bonsplit drop behavior and steady-state preference collection.
• Local build/tests not run per repo/user constraints. CI should validate.
• Localization audit: no user-facing strings were added or changed. The only new strings are DEBUG-only diagnostic text.

---

Note

Medium Risk
Touches sidebar drag/drop and Bonsplit move-to-workspace flows with timing-sensitive pending-drop logic; steady-state performance improves but regressions could affect large-workspace DnD.

Overview
Stops the sidebar from collecting per-workspace row frame anchors and the overlayPreferenceValue geometry reader unless a drag actually needs drop targets—either a normal sidebar tab drag (draggedTabId) or an active Bonsplit workspace drop signaled separately from SidebarDragState.

Bonsplit drags now turn on that collection via AppKit pasteboard callbacks, feed targets through a TargetBridge / TargetWriter, and can defer a drop until row frames exist—without tearing down the drop NSView when collection flips on (overlay stays mounted outside the gated branch).

Adds SidebarDropPlanner.shouldCollectWorkspaceDropTargets, a sidebarWorkspaceFrameAnchor modifier, and unit tests for when collection is on vs off.

^{Reviewed by Cursor Bugbot for commit beb318e. Bugbot is set up for automated code reviews on this repo. Configure here.}

Summary by CodeRabbit

• New Features

  • Deferred handling for workspace drops so transfers are queued and completed once targets appear.

• Bug Fixes

  • Conditional collection of workspace drop targets to reduce spurious anchors and improve drag-and-drop accuracy.
  • More robust drop-indicator and teardown behavior during complex/late-arriving drops.

• Tests

  • Added tests verifying when workspace drop-target collection is active.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
cmux	Ready	Preview, Comment	Jun 4, 2026 8:00am
cmux-staging	Building	Preview, Comment	Jun 4, 2026 8:00am

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

📝 Walkthrough

Walkthrough

Gates per-row frame-anchor collection so workspace drop-target frames are only published during an active tab drag or when bonsplit drop mode is enabled. Adds a centralized predicate, a transient ContentView state flag, conditional anchor application in headers/rows, overlay refactor, and pending-drop resolution in the Bonsplit drop view.

Changes

Gate workspace drop target collection on drag to restore sidebar virtualization

Layer / File(s)	Summary
Decision predicate for workspace drop target collection Sources/Sidebar/SidebarDropPlanner.swift, cmuxTests/SidebarWorkspaceDropPlannerTests.swift	SidebarDropPlanner.shouldCollectWorkspaceDropTargets returns true when a tab drag is in progress or bonsplit workspace drop mode is active; unit tests verify no-drag, active-drag, and bonsplit-drop cases.
Conditional anchor application in headers Sources/VerticalTabsSidebar+WorkspaceGroups.swift	sidebarWorkspaceGroupHeader gains shouldCollectWorkspaceDropTargets param, stores header locally, and applies the SidebarWorkspaceRowFramePreferenceKey only when collection is enabled.
Transient state flag and teardown management Sources/ContentView.swift	isBonsplitWorkspaceDropTargetCollectionActive transient state tracks bonsplit workspace drop collection and is cleared during drag teardown/defensive reset paths.
Workspace list refactor and conditional overlay composition Sources/ContentView.swift	workspaceRows is refactored into a @ViewBuilder, extracts bonsplitWorkspaceDropOverlay(), and conditionally uses overlayPreferenceValue+GeometryReader to map anchors to WorkspaceDropTarget only when collection is enabled; otherwise renders baseline overlay with empty targets.
Conditional per-row anchor emission Sources/ContentView.swift	workspaceRow binds row locally and attaches anchorPreference(SidebarWorkspaceRowFramePreferenceKey) only when shouldCollectWorkspaceDropTargets is true, otherwise preserves previous padding without emitting anchors.
Drop overlay callback wiring and drag lifecycle management Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift	Overlay accepts setWorkspaceDropTargetCollectionActive and isWorkspaceDropTargetCollectionActive, replaces direct targets with a TargetBridge, adds isRequestingWorkspaceDropTargets and PendingDrop handling, supports pending transfers when targets are missing, resolves pending drops when targets arrive, and updates drag lifecycle to avoid premature deactivation of indicators.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related PRs

• manaflow-ai/cmux#4989: Both PRs touch sidebarWorkspaceGroupHeader and header/drag handling; changes are code-adjacent and may overlap.

Suggested reviewers

• Ari4ka

Poem

🐰 I nudged the anchors, soft and bright,

Only when a tab is dragged do I light,
I hold a pending hop until targets show,
Then tap the path where falling bits should go,
A tiny bridge, a tidy drop — now off I go.

---

Caution

Pre-merge checks failed

Please resolve all errors before merging. Addressing warnings is optional.

• Ignore

❌ Failed checks (1 error, 1 warning)

Check name	Status	Explanation	Resolution
Cmux Swift Actor Isolation	❌ Error	TargetBridge class in SidebarBonsplitTabWorkspaceDropOverlay.swift is shared mutable reference type without explicit actor isolation, accessed from SwiftUI and AppKit contexts.	Mark TargetBridge with @MainActor, or use a lock with documented reason, or apply @unchecked Sendable with safety explanation.
Docstring Coverage	⚠️ Warning	Docstring coverage is 3.03% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (16 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title 'Fix sidebar workspace frame collection virtualization' clearly and specifically describes the main change: disabling unconditional workspace frame collection to restore LazyVStack virtualization.
Linked Issues check	✅ Passed	All changes directly address the objectives in #5323: gates SidebarWorkspaceRowFramePreferenceKey emitters, gates the overlayPreferenceValue reader, keeps Bonsplit overlay lightweight, and adds test coverage for the collection policy, successfully restoring LazyVStack virtualization.
Out of Scope Changes check	✅ Passed	All changes are directly scoped to the collection policy and virtualization fix: workspace row preference gating, overlay collection toggling, Bonsplit pending-drop handling with deferred teardown, and related test coverage. No unrelated or out-of-scope modifications were introduced.
Cmux Swift Blocking Runtime	✅ Passed	No blocking runtime primitives introduced; pre-existing blocking constructs found only in ContentView.swift, not in the PR's 4 target files.
Cmux No Hacky Sleeps	✅ Passed	PR contains only Swift files; check explicitly covers TypeScript/JavaScript/shell/build scripts only. Swift timing is covered by separate rule.
Cmux Algorithmic Complexity	✅ Passed	PR gates the full-collection scan and anchor preference modifiers behind shouldCollectWorkspaceDropTargets, so they only execute during drag/drop operations when needed, not unconditionally.
Cmux Swift Concurrency	✅ Passed	Three new DispatchQueue.main.async calls are all at AppKit/SwiftUI boundaries: SwiftUI-NSView bridge, NSViewRepresentable lifecycle, and AppKit drag callbacks. No forbidden patterns found.
Cmux Swift @Concurrent	✅ Passed	PR introduces no async functions, @concurrent annotations, or nonisolated async patterns. All synchronous code; DispatchQueue.main calls appropriately used from MainActor contexts.
Cmux Swift File And Package Boundaries	✅ Passed	SidebarBonsplitTabWorkspaceDropOverlay (426 lines) has clear single responsibility and qualifies as allowed AppKit bridge code per rules.
Cmux Swift Logging	✅ Passed	PR's sidebar changes contain no logging violations. The only NSLog found is pre-existing code in feedback submission, wrapped in #if DEBUG (allowed case per swift-logging.md).
Cmux User-Facing Error Privacy	✅ Passed	PR contains only internal drag-drop UI refactoring with no user-facing error messages, alerts, or sensitive data exposed in accordance with user-facing error privacy rules.
Cmux Full Internationalization	✅ Passed	PR contains no user-facing strings or catalog changes; all debug logs wrapped in #if DEBUG, strings are internal identifiers, and no localization files modified.
Cmux Swiftui State Layout	✅ Passed	No ObservableObject/@published patterns. State mutations in proper lifecycle callbacks. Row subtrees receive snapshots not stores. GeometryReader conditionally gated.
Cmux Architecture Rethink	✅ Passed	Bounds collection gated by shouldCollectWorkspaceDropTargets policy eliminates unconditional aggregation. Pending-drop mechanism is required AppKit-SwiftUI callback bridge with documented rationale.
Cmux Swift Auxiliary Window Close Shortcuts	✅ Passed	No standalone NSWindow/NSPanel/NSWindowController/Window/WindowGroup added. Changes gating drop-target collection within main workspace sidebar (allowed case).
Description check	✅ Passed	The PR description comprehensively covers all required sections: a detailed summary explaining what changed and why, thorough testing methodology including reproduction steps and before/after verification, clear checklist items, and explicit notes about CI validation.

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch issue-5323-sidebar-virtualize

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@Sources/ContentView.swift`:
- Around line 12218-12221: Compute
SidebarDropPlanner.shouldCollectWorkspaceDropTargets once in workspaceRows
(using dragState.draggedTabId and isBonsplitWorkspaceDropTargetCollectionActive)
and pass that boolean into workspaceRow as an extra parameter (or extract it to
a shared computed property used by both workspaceRows and workspaceRow). Update
all callers that currently recompute the predicate (the occurrences around
workspaceRows and the separate workspaceRow usage) to use the new
parameter/property, and remove the duplicated calls to
SidebarDropPlanner.shouldCollectWorkspaceDropTargets to keep the decision
centralized.
- Line 10452: The SwiftLint warning is triggered because the SwiftUI state
property is not private; change the declaration of
isBonsplitWorkspaceDropTargetCollectionActive to be private (mark the `@State` var
isBonsplitWorkspaceDropTargetCollectionActive as private) inside
VerticalTabsSidebar so the state is encapsulated and satisfies the
private_swiftui_state rule.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 27fcb2ac-38b2-4e92-bdc3-15efdd5facea

📥 Commits

Reviewing files that changed from the base of the PR and between 2c35c54 and d5f7959.

📒 Files selected for processing (5)

• Sources/ContentView.swift
• Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift
• Sources/Sidebar/SidebarDropPlanner.swift
• Sources/VerticalTabsSidebar+WorkspaceGroups.swift
• cmuxTests/SidebarWorkspaceDropPlannerTests.swift

[coderabbitai]

Actionable comments posted: 3

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@Sources/ContentView.swift`:
- Around line 12243-12259: The
overlayPreferenceValue(SidebarWorkspaceRowFramePreferenceKey.self) +
GeometryReader block is always mounted which forces collection/resolution of all
row anchors; instead only install the overlay when
shouldCollectWorkspaceDropTargets is true. Replace the unconditional
rows.overlayPreferenceValue { … GeometryReader { …
bonsplitWorkspaceDropOverlay(...) } } with a conditional that returns rows as-is
when shouldCollectWorkspaceDropTargets is false and applies the
overlayPreferenceValue/GeometryReader/bonsplitWorkspaceDropOverlay only when
shouldCollectWorkspaceDropTargets is true (referencing overlayPreferenceValue,
SidebarWorkspaceRowFramePreferenceKey, GeometryReader,
bonsplitWorkspaceDropOverlay, shouldCollectWorkspaceDropTargets, and
renderContext.tabs to locate the code).

In `@Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift`:
- Line 55: The call to nsView.performPendingDropIfPossible() inside updateNSView
can synchronously invoke the closures wired there
(nsView.performExistingWorkspaceMove / performNewWorkspaceMove /
nsView.setDropIndicator) which mutate `@Binding` state (selectedTabIds,
lastSidebarSelectionIndex, dropIndicator) during the SwiftUI view update pass;
move the performPendingDropIfPossible invocation out of updateNSView so it runs
after the current runloop tick (e.g. dispatch async to main queue or schedule
from the NSView/Coordinator callback) ensuring updateNSView only wires the
closures and does not trigger them synchronously.
- Around line 136-168: performDragOperation currently accepts a transfer and
performs the move but doesn't clear the cached pendingDrop, and
draggingExited/concludeDragOperation return early without clearing it, allowing
a stale PendingDrop to be replayed by performPendingDropIfPossible; update
performDragOperation to nil-out pendingDrop after a successful accept (i.e., in
the accepted-transfer branch after perform(action:transfer:)), and also clear
pendingDrop in draggingExited and concludeDragOperation teardown paths so the
stored PendingDrop cannot outlive the gesture and be replayed later by
performPendingDropIfPossible or updateNSView.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 71a08416-49a1-4f24-83f1-292fbf0fdaf6

📥 Commits

Reviewing files that changed from the base of the PR and between d5f7959 and 9085835.

📒 Files selected for processing (2)

• Sources/ContentView.swift
• Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift

[cubic-dev-ai]

1 issue found across 2 files (changes from recent commits).

<sub>Tip: Review your code locally with the cubic CLI to iterate faster.

Re-trigger cubic</sub>

[greptile-apps]

Greptile Summary

This PR gates SidebarWorkspaceRowFramePreferenceKey anchor emission and the overlayPreferenceValue reader behind a new SidebarDropPlanner.shouldCollectWorkspaceDropTargets policy, stopping the sidebar from forcing SwiftUI preference/layout work on every unrelated state change when no drag is active. A TargetBridge class decouples SwiftUI frame delivery from AppKit drop completion, and a stable outer overlay preserves NSView identity across gate flips.

• Collection gate: SidebarWorkspaceFrameAnchorModifier wraps each row/group-header so anchors are only emitted during an active sidebar drag or Bonsplit workspace drop; the overlayPreferenceValue reader is installed on the same condition.
• Pending-drop path: When performDragOperation fires before frames arrive, a PendingDrop is queued; TargetBridge.updateTargets signals performPendingDropIfPossible on the next main-queue turn when frames land. A bounded recursive main-queue poll in completeOrClearPendingDropAfterDragTeardown acts as a teardown safety net but introduces a timing-based synchronization dependency (see inline comment).
• Tests: Three new policy-gate unit tests in SidebarWorkspaceDropPlannerTests.swift verify the no-drag, sidebar-drag, and Bonsplit-drop cases.

Confidence Score: 4/5

Safe to merge with one follow-up: the teardown polling path can silently discard a Bonsplit workspace move on a loaded system before the real signal path is hardened.

The collection gate, TargetBridge signal path, and NSView-identity fix are all correct and well-tested. The one issue is completeOrClearPendingDropAfterDragTeardown, which bets on SwiftUI delivering frames within 3 main-queue turns after drag teardown. Under load with 100+ workspaces the preference update can take longer; if it does, a user who successfully drops a Bonsplit tab sees nothing move. The TargetBridge signal path already handles the normal case, so this polling is a timing-dependent heuristic with a hidden failure mode.

Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift — specifically the completeOrClearPendingDropAfterDragTeardown teardown path.

Important Files Changed

Filename	Overview
Sources/Sidebar/SidebarDropPlanner.swift	Adds the shouldCollectWorkspaceDropTargets policy seam — a trivial boolean combinator with correct logic and matching tests.
cmuxTests/SidebarWorkspaceDropPlannerTests.swift	Adds three focused unit tests covering the no-drag, sidebar-drag, and Bonsplit-drop policy branches; straightforward and correct.
Sources/VerticalTabsSidebar+WorkspaceGroups.swift	Threads shouldCollectWorkspaceDropTargets to group headers and applies the stable SidebarWorkspaceFrameAnchorModifier; no issues.
Sources/ContentView.swift	Adds isBonsplitWorkspaceDropTargetCollectionActive state, splits workspaceRows into gated reader + stable Bonsplit overlay, and introduces SidebarWorkspaceFrameAnchorModifier to gate per-row anchor emission. Architecturally sound; the TargetBridge @State and always-mounted overlay correctly preserve NSView identity across gate flips.
Sources/Sidebar/SidebarBonsplitTabWorkspaceDropOverlay.swift	Largest change: adds TargetBridge, TargetWriter, PendingDrop, and deferred-completion machinery. The TargetBridge signal path (updateTargets → performPendingDropIfPossible) is correct, but completeOrClearPendingDropAfterDragTeardown introduces a bounded recursive main-queue polling loop as a timing-based safety net, which violates the blocking/timing synchronization rule.

Sequence Diagram

sequenceDiagram
    participant OS as macOS Drag Session
    participant NSView as SidebarBonsplitTabWorkspaceDropView
    participant Bridge as TargetBridge
    participant SW as SwiftUI (TargetWriter)
    participant State as VerticalTabsSidebar @State

    OS->>NSView: draggingEntered
    NSView->>State: setWorkspaceDropTargetCollectionActive(true)
    State->>SW: overlayPreferenceValue reader installed
    SW->>Bridge: updateTargets([...frames...])
    Bridge-->>NSView: (stores targets)

    OS->>NSView: performDragOperation (targets empty)
    NSView->>NSView: "pendingDrop = PendingDrop(requestId, point, transfer)"
    NSView-->>OS: return true (deferred)

    SW->>Bridge: updateTargets([...frames arrive...])
    Bridge->>NSView: async performPendingDropIfPossible()
    NSView->>NSView: perform(action, transfer)
    NSView->>State: setWorkspaceDropTargetCollectionActive(false)
    State->>SW: overlayPreferenceValue reader removed
    SW->>Bridge: clearTargets()

    Note over OS,NSView: Teardown path (draggingExited / concludeDragOperation with pendingDrop set)
    OS->>NSView: draggingExited
    NSView->>NSView: "completeOrClearPendingDropAfterDragTeardown(remainingFrameWaits=3)"
    loop up to 3 main-queue hops
        NSView->>NSView: targets.isEmpty? recurse
    end
    NSView->>NSView: clearPendingDrop() or performPendingDropIfPossible()
    NSView->>State: setWorkspaceDropTargetCollectionActive(false)

Loading

_{Reviews (3): Last reviewed commit: "fix(sidebar): keep Bonsplit drop overlay..." | Re-trigger Greptile}

[cubic-dev-ai]

1 issue found across 5 files

<sub>Reply with feedback, questions, or to request a fix.

Re-trigger cubic</sub>

[cubic-dev-ai]

1 issue found across 2 files (changes from recent commits).

<sub>Tip: Review your code locally with the cubic CLI to iterate faster.

Re-trigger cubic</sub>

[cubic-dev-ai]

You're iterating quickly on this pull request. To help protect your rate limits, cubic has paused automatic reviews on new pushes for now—when you're ready for another review, comment @cubic-dev-ai review.

[lawrencecchen]

Reviewed this against the #2586 diagnosis, built it locally, and dogfooded drag-and-drop. The fix is correct and the right one — gating the per-row .anchorPreference(.bounds) collection restores LazyVStack virtualization, which is the dominant cost of the sidebar beachball. Both row and group-header emitters are covered; the Bonsplit capture-overlay + TargetBridge + deferred replay keep cross-window drops working.

One fix pushed (beb318ef2)

Drop NSView identity instability across the gate flip. The drop-capture SidebarBonsplitTabWorkspaceDropView was inside rowsWithDropOverlay, which is returned from both branches of if shouldCollectWorkspaceDropTargets { … } else { … }. The two branches have distinct SwiftUI identity, so the gate flip on draggingEntered (shouldCollect false→true) tore down and recreated the drop NSView mid-drag, orphaning the in-flight drag — which is what the pendingDrop/requestId/frame-wait machinery is papering over.

Fix: moved the overlayPreferenceValue reader (the virtualization-defeating part) into a gated helper applied to the rows, and mounted the drop-capture overlay at the stable outer level so its identity never changes when the gate flips. Virtualization is preserved (the reader stays conditional); only the consumer NSView becomes identity-stable. Dogfooded: local reorder + cross-window Bonsplit drop both work, including drops at the gate-flip moment and onto just-scrolled-in rows.

Follow-ups (not blocking; not yet applied — they're drag-timing/cleanup that want their own verification)

• completeOrClearPendingDropAfterDragTeardown polls 3 frames then silently clears — a Bonsplit drop can be lost if row anchors take >3 frames to publish (large list / mid-scroll). The real "targets arrived" signal already exists in TargetBridge.updateTargets; driving teardown off that would remove both the lost-drop and the wasted-poll cases.
• Duplicate pending-drop kick (updateNSView :96 and TargetBridge.updateTargets :14 both schedule performPendingDropIfPossible on the same condition).
• isWorkspaceDropTargetCollectionActive prop is a round-tripped mirror; its only use (clearPendingDropIfIdle) already self-guards on the NSView's authoritative isRequestingWorkspaceDropTargets.
• bonsplitWorkspaceDropOverlay() rebuilds ~7 escaping closures per workspaceRows body pass via the always-on .overlay.

Process note: I could not run an after-profile through the usual harness (instance conflict during the run), but the perf win holds by construction — the reader stays gated, so at rest the all-row anchor collection is not installed.

[lawrencecchen]

Fresh field evidence: a real 15.5 s hang spindump, scroll-triggered, same LazySubviewPlacements loop this PR fixes

A user force-quit a beachballed nightly during sidebar scroll and captured the macOS hang report. It corroborates this PR's root cause directly.

• Build: 0.64.12-nightly.2693970953401 (pre-Fix sidebar workspace frame collection virtualization #5325 — has the bug, not the fix), macOS 26.5, Mac17,6, 128 GB.
• Event: hang, Duration: 15.55s (unresponsive ~14 s before sampling).
• Main thread is CPU-bound spinning — 1.19 s of CPU in the 1.3 s sample window — i.e. grinding, not deadlocked. 100% of main-thread samples are inside one SwiftUI ViewGraph transaction.

Main-thread stack (trimmed) — bottoms out in the sidebar LazyVStack placement/measure loop:

NSApplication run → _DPSNextEvent → __CFRunLoopDoObservers → NSRunLoop.flushObservers
 → NSHostingView.beginTransaction → ViewGraphRootValueUpdater.updateGraph
  → GraphHost.flushTransactions → runTransaction → AG::Subgraph::update → UpdateStack::update
   → LazySubviewPlacements.updateValue → .placeSubviews
    → _LazyLayoutViewCache.withMutableCacheState
     → LazyStack.place → ForEachList.applyNodes → ForEachState.forEachItem
      → (nested) ModifiedViewList.applyNodes ×4 → BaseViewList.applyNodes
       → StackPlacement.place → LazyHVStack.lengthAndSpacing → LayoutEngineBox.lengthThatFits
   (sibling branch) → LayoutEngineBox.childGeometries(at:origin:) → ViewLayoutEngine.childGeometries

This is the #5323 mechanism — per-row frame collection defeating LazyVStack virtualization so a placement pass re-measures the whole list — and scroll is the trigger: scrolling drives LazySubviewPlacements.placeSubviews, which with all-row frame collection re-lays-out every row instead of the ~viewport, producing a multi-second hang.

This PR gates that collection to active drag, so a no-drag scroll pass only places visible rows. The hang can't be re-measured on this exact build (it predates the PR), but it pins the failure mode and the scroll trigger.

Caveat: the nightly is a release build with no dSYM available to the OS spindump, so the app's own frames (VerticalTabsSidebar.workspaceRows, the overlayPreferenceValue reader) aren't symbol-named — but the SwiftUI LazyVStack/ForEachList layout signature during sidebar scroll is unambiguous. Full report retained locally.

Stale: reviewed an older commit (d5f7959). The 3 points are addressed/guarded in the current tip (beb318e) — reader gated, drop kicks deferred via DispatchQueue.main.async, stale-replay guarded by requestId.

[lawrencecchen]

@azooz2003-bit heads up — the workspace-sidebar virtualization issue (#2586 / #5323) was causing real hard hangs: a user hit a 15.5s beachball just scrolling the sidebar (CPU-bound spinning in the LazyVStack placeSubviews / ForEachList layout loop, captured in a hang spindump).

This just merged here in #5325 (572e9483) — it gates the per-row drop-target .anchorPreference(.bounds) collection to active-drag, so idle/scroll passes stop re-measuring every workspace row and LazyVStack virtualization is restored.

Since you did the recent sidebar lazy + @Observable dragState work in #4736, you might want to look over the merged change when you get a chance — especially the drop-overlay identity handling and the deferred Bonsplit drop replay.