Gate hidden-grid cell rebuilds on surviving the reveal

[SimonHeybrock]

Fixes #1216. Partially addresses #1219 (the ValueError handler; topology-driven occupancy is left for a follow-up).

What

Every session's poll pass rebuilt the cell widgets of every enabled grid in the shared topology, visible or not — at page load and again on every layer version bump (job restarts, plotter swaps, errors). For a grid with no viewer in any session such a build is a placeholder: frame flushes skip layers without viewer tokens, so the reveal's 0→1 activation bumps the layer version and rebuilds the cell anyway, discarding the hidden build. The cost is per session and serialized on the shared IOLoop, so N parked sessions pay it N times back-to-back on every bump.

The poll pass now skips a hidden cell's rebuild unless another session holds a viewer token on one of its layers — the one case where the build is a real plot that survives the reveal and pre-warms the tab switch. Skipped rebuilds leave the session's signature/version records stale, so the reveal pass builds the cell once; N bumps while hidden coalesce into that single build.

That reveal pass now runs before the tab's Bokeh models are materialized rather than after. Deferring the builds means a revealed grid's PlotGrid holds nothing but the empty-cell placeholders it was constructed with, and Panel materializes the tab from whatever it holds at the moment of the switch. Building afterwards made the reveal two patches, and in between showed the user "Click to add plot" over positions that are occupied. _BatchedTabs gained a hook called ahead of the materialization cascade — the only point where a change to the tab's content still lands in the same materialization, since Panel registers _update_active in its own constructor and any active watcher added later necessarily runs once the models exist.

Consequences handled along the way:

• A revealed grid's widgets can now lag topology for one pass, so completing the plot wizard on a stale empty cell can hit an occupied position. add_cell's ValueError was uncaught in that handler (already reachable via the cross-session wizard race, Empty-cell click can raise ValueError: PlotGrid occupancy comes from inserted widgets, not topology #1219); it now shows an error notification.
• The pn.state.execute wrapper around cell insertion described a deferral that never happens (the pass holds the document lock, so it ran inline); the insert is now direct and the dead removed-cell guard is gone.
• A cell rebuilt because it is missing from the session's widget map recorded no last_seen_version, so the reveal's activation bump — raised earlier in the same pass, after the version scan — rebuilt it again on the next pass. Harmless before this change, because the widget it discarded had been built while hidden and never rendered; with the gate, the discarded widget has been rendered and its plot stays subscribed to the layer pipe, doubling the grid's render cost for the rest of the session. Rebuilds now record the versions as of just before the build.
• The reveal hook logs and swallows exceptions. It sits on the tab-switch path, which nothing else guards, and an escaping exception aborts the materialization that follows and leaves the tab blank for the rest of the session. Swallowing degrades to the deferred build, which SessionUpdater guards.

Measured

Fake backend, committed dummy fixture (2 grids, 6 cells, 9 layers), server-side timing of _build_cell and the poll pass plus pipe-subscriber and DynamicMap-callback counts, driven through Playwright; main vs this branch, 2–3 repeats each.

Session parked on Workflows, both grids hidden, no other viewer:

	main	this branch
page load	6 builds, ~40 ms pass wall	0 builds, 0.7 ms
three job stops while hidden	3 builds, ~25 ms	0 builds, 0.8 ms

With a second session viewing a grid, the parked session still pre-warms that grid's cells and skips the unviewed one's.

The reveal of the 3-cell grid was measured separately, on the merged branch, 8 reveals per variant with a fresh server for each (a session that closed while viewing the grid still holds a viewer token and would pre-warm the next reveal), toggling only the pre-build hook:

	build after materialization	build before
server, reveal total	552 ms (455–814)	660 ms (475–758)
empty-cell placeholders on screen	503 ms (382–730)	none
client, time until cells appear	1901 ms (1727–1973)	1684 ms (1374–1778)
client, longest main-thread block	1158 ms (871–1272)	882 ms (811–969)
client console errors	5, every run	0, every run

So the reveal trades ~110 ms of shared IOLoop for ~220 ms off the browser and the removal of the flash. The ~50 ms per layer of Bokeh model construction (#1203) is untouched and still dominates what remains. The console errors that stop firing are bokeh#15274 (parent_style), whose trigger was the placeholder-to-cell children change on the GridBox and which drops the rest of the patch, and four blocked CDN resource loads from markup panes built after the tab had rendered (the #1154 fallback path).

Absolute figures drift by 15–20% between sessions on a contended devcontainer, and the client half is software-raster Chromium, so read the columns against each other rather than as absolutes. Sub-samples of 3 are not enough to separate the client-side difference from that drift; the table is 8 per arm.

Test plan

Automated tests cover the gate (hidden cell not built, reveal builds it, viewer token preserves the pre-warm build, bumps while hidden defer to the reveal), the single build per reveal, the occupied-position error path, and that a revealed grid's cells exist at the moment Panel materializes the tab.

Manual checks:

• Reveal of a grid whose cells were deferred shows no objectionable empty-cell flash before the widgets appear

Merged in

The subscriber leak this branch first surfaced — rebuilding a cell while its grid is visible left the replaced widget's plot subscribed to the layer pipe — was filed as #1224 and fixed on main by #1226, which is merged in here. The reveal numbers above are measured on the merged state.

🤖 Generated with Claude Code

[SimonHeybrock]

LGTM. UX is also better since we do not see the empty cells for a second when first switching to a tab -- instead a blank page shows.