@dimina-kit/devtools 0.4.0-dev.20260803105710 → 0.4.0-dev.20260828092243

package/dist/main/services/views/overlay-panels-view.js

@@ -1,150 +1,268 @@
 import { WebContentsView } from 'electron';
-import path from 'path';
+import { createOverlayPanel } from '@dimina-kit/electron-deck/main';
 import { mainPreloadPath } from '../../utils/paths.js';
 import { applyNavigationHardening } from '../../windows/navigation-hardening.js';
 import * as layout from '../layout/index.js';
 import { HEADER_H } from '../../../shared/constants.js';
 import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
-import { destroyChildView } from './destroy-child-view.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 export function createOverlayPanelsView(ctx, reconciler, deps) {
-    let settingsView = null;
-    let popoverView = null;
     function overlayHeaderHeight() {
         return HEADER_H + deps.getHostToolbarHeight();
     }
-    // settings/popover bounds are main-computed; publish them into overlayDesired
-    // and let the reconciler place them (they are top-tier layers, so a reorder
-    // keeps them above every base overlay — the old raiseTopOverlays is gone).
-    function applySettingsBounds() {
-        if (!settingsView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.settings, {
-            viewId: VIEW_ID.settings,
-            placement: {
-                visible: true,
-                bounds: layout.computeSettingsBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.settings,
-        });
-        reconciler.reconcileNow();
+    function overlayDesiredSetter(viewId, layer) {
+        return (bounds) => {
+            if (bounds === null) {
+                reconciler.deleteOverlayDesired(viewId);
+            }
+            else {
+                reconciler.setOverlayDesired(viewId, {
+                    viewId,
+                    placement: { visible: true, bounds },
+                    layer,
+                });
+            }
+            reconciler.reconcileNow();
+        };
     }
-    function applyPopoverBounds() {
-        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.popover, {
-            viewId: VIEW_ID.popover,
-            placement: {
-                visible: true,
-                bounds: layout.computePopoverBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.popover,
-        });
-        reconciler.reconcileNow();
+    const settingsPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/settings/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.settings, VIEW_LAYER.settings),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.settings, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.settings, view),
+        readyMode: 'manual',
+    });
+    const popoverPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/popover/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.popover, VIEW_LAYER.popover),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.popover, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.popover, view),
+        pushData: (view, data) => ctx.notify.popoverInit(view, data),
+        readyMode: 'manual',
+    });
+    const tooltipPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/tooltip/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.tooltip, VIEW_LAYER.tooltip),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.tooltip, { getView }),
+        prepareView: (view) => {
+            const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+            reconciler.prepareView(VIEW_ID.tooltip, view, {
+                x: 0,
+                y: 0,
+                width: Math.max(1, width),
+                height: Math.max(1, height),
+            });
+        },
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.tooltip, view),
+        pushData: (view, data) => ctx.notify.tooltipInit(view, data),
+        readyMode: 'manual',
+    });
+    /**
+     * Both devtools-owned dialog panels occupy the full main-window content
+     * rect (they render their own centered card + backdrop), so unlike
+     * settings/popover/tooltip they need no anchor-derived bounds computation —
+     * just the window's current content size, recomputed on every show/resize.
+     */
+    function fullWindowBounds() {
+        const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+        return { x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) };
     }
+    const projectCreateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/project-create-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.projectCreateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.projectCreateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.projectCreateDialog, view),
+        pushData: (view, data) => ctx.notify.projectCreateInit(view, data),
+        readyMode: 'manual',
+    });
+    const updateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/update-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.updateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.updateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.updateDialog, view),
+        pushData: (view, data) => ctx.notify.updateAvailable(view, data),
+        readyMode: 'manual',
+    });
+    let tooltipRequestId = 0;
+    let activeTooltip = null;
     async function showSettings() {
-        if (!settingsView) {
-            settingsView = new WebContentsView({
-                webPreferences: {
-                    nodeIntegration: false,
-                    contextIsolation: true,
-                    sandbox: false,
-                    preload: mainPreloadPath,
-                },
-            });
-            // Overlay loads mainPreloadPath, so the same navigation rules as the
-            // main window apply — see navigation-hardening.ts.
-            applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
-            // Transparent backing: the settings view now spans the whole content area
-            // (computeSettingsBounds) and its renderer paints a transparent backdrop +
-            // an opaque right-side panel, so the underlying editor/simulator show
-            // through and a backdrop click closes the overlay (mirrors the popover).
-            settingsView.setBackgroundColor('#00000000');
-            await settingsView.webContents.loadFile(path.join(ctx.rendererDir, 'entries/settings/index.html'));
-        }
-        applySettingsBounds();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        settingsPanel.show(undefined, layout.computeSettingsBounds(w, h, overlayHeaderHeight()));
+        await settingsPanel.whenReady();
     }
     function hideSettings() {
-        reconciler.deleteOverlayDesired(VIEW_ID.settings);
-        reconciler.reconcileNow();
+        settingsPanel.hide();
     }
     function showPopover(data) {
+        // Popover carries no state across opens (always fresh init data) — force a
+        // brand-new instance rather than reusing/repositioning a live one (and
+        // notify like any other close, via the shared hidePopover()).
         hidePopover();
-        const popover = new WebContentsView({
-            webPreferences: {
-                nodeIntegration: false,
-                contextIsolation: true,
-                sandbox: false,
-                preload: mainPreloadPath,
-            },
-        });
-        // Popover overlay loads mainPreloadPath — same navigation rules apply.
-        applyNavigationHardening(popover.webContents, ctx.rendererDir);
-        popoverView = popover;
-        popover.setBackgroundColor('#00000000');
-        applyPopoverBounds();
-        popover.webContents.once('did-finish-load', () => {
-            ctx.notify.popoverInit(popover, data);
-        });
-        popover.webContents.loadFile(path.join(ctx.rendererDir, 'entries/popover/index.html'));
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        popoverPanel.show(data, layout.computePopoverBounds(w, h, overlayHeaderHeight()));
     }
     function hidePopover() {
-        if (!popoverView)
+        if (!popoverPanel.isPresent())
             return;
+        popoverPanel.destroy();
         reconciler.deleteOverlayDesired(VIEW_ID.popover);
-        // Destroy the WCV first (removeChildView + close), THEN reconcile: the detach
-        // op then finds the view already gone and does not double-removeChildView.
-        destroyChildView(ctx.windows.mainWindow, popoverView);
-        popoverView = null;
         reconciler.reconcileNow();
         ctx.notify.popoverClosed();
     }
+    function prepareTooltip() {
+        tooltipPanel.prepare();
+    }
+    function showTooltip(data) {
+        const requestId = ++tooltipRequestId;
+        activeTooltip = { requestId, anchor: data.anchor };
+        const [contentWidth = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.show({
+            requestId,
+            text: data.text,
+            maxWidth: layout.computeTooltipMaxWidth(contentWidth),
+        }, null);
+    }
+    function hideTooltip() {
+        activeTooltip = null;
+        tooltipPanel.hide();
+    }
+    function showProjectCreateDialog(data) {
+        projectCreateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideProjectCreateDialog() {
+        projectCreateDialogPanel.hide();
+    }
+    function showUpdateDialog(data) {
+        updateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideUpdateDialog() {
+        updateDialogPanel.hide();
+    }
+    function notifyUpdateDownloadProgress(percent) {
+        const wc = updateDialogPanel.getWebContents();
+        if (!wc)
+            return;
+        wc.send(UpdateChannel.DownloadProgress, { percent });
+    }
+    function markOverlayReady(webContentsId) {
+        settingsPanel.markReady(webContentsId);
+        popoverPanel.markReady(webContentsId);
+        tooltipPanel.markReady(webContentsId);
+        projectCreateDialogPanel.markReady(webContentsId);
+        updateDialogPanel.markReady(webContentsId);
+    }
+    function applyTooltipMeasurement(webContentsId, measurement) {
+        const active = activeTooltip;
+        if (!active || active.requestId !== measurement.requestId)
+            return;
+        if (tooltipPanel.getWebContentsId() !== webContentsId)
+            return;
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.reposition(layout.computeTooltipBounds(active.anchor, w, h, measurement));
+    }
     function reapplyPresentOverlays() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
-        if (reconciler.hasOverlayDesired(VIEW_ID.popover))
-            applyPopoverBounds();
+        // Fire-and-forget re-trigger — a crash between this call and the panel
+        // becoming ready now rejects whenReady() (see overlay-panel.ts teardown);
+        // handleViewBroken() already logs it, nothing more to do here.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
+        if (popoverPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.popover)) {
+            const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+            popoverPanel.reposition(layout.computePopoverBounds(w, h, overlayHeaderHeight()));
+        }
+        if (projectCreateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.projectCreateDialog)) {
+            projectCreateDialogPanel.reposition(fullWindowBounds());
+        }
+        if (updateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.updateDialog)) {
+            updateDialogPanel.reposition(fullWindowBounds());
+        }
     }
     function applySettingsBoundsIfPresent() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
+        // See reapplyPresentOverlays() above for why this swallows a rejection.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
     }
     function destroySettings() {
-        destroyChildView(ctx.windows.mainWindow, settingsView);
-        settingsView = null;
+        activeTooltip = null;
+        settingsPanel.destroy();
+        tooltipPanel.destroy();
+    }
+    function destroyDialogs() {
+        projectCreateDialogPanel.destroy();
+        updateDialogPanel.destroy();
     }
-    reconciler.registerView(VIEW_ID.settings, { getView: () => settingsView });
-    reconciler.registerView(VIEW_ID.popover, { getView: () => popoverView });
     return {
         showSettings,
         hideSettings,
         showPopover,
         hidePopover,
+        prepareTooltip,
+        showTooltip,
+        hideTooltip,
+        markOverlayReady,
+        applyTooltipMeasurement,
+        showProjectCreateDialog,
+        hideProjectCreateDialog,
+        showUpdateDialog,
+        hideUpdateDialog,
+        notifyUpdateDownloadProgress,
         reapplyPresentOverlays,
         applySettingsBoundsIfPresent,
         destroySettings,
-        getSettingsWebContents: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents;
-        },
-        getSettingsWebContentsId: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents.id;
-        },
-        getPopoverWebContentsId: () => {
-            if (!popoverView)
-                return null;
-            if (popoverView.webContents.isDestroyed())
-                return null;
-            return popoverView.webContents.id;
-        },
+        destroyDialogs,
+        getSettingsWebContents: () => settingsPanel.getWebContents(),
+        getSettingsWebContentsId: () => settingsPanel.getWebContentsId(),
+        getPopoverWebContentsId: () => popoverPanel.getWebContentsId(),
+        getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
+        getProjectCreateDialogWebContentsId: () => projectCreateDialogPanel.getWebContentsId(),
+        getUpdateDialogWebContentsId: () => updateDialogPanel.getWebContentsId(),
     };
 }
 //# sourceMappingURL=overlay-panels-view.js.map

package/dist/main/services/views/placement-reconciler.d.ts

@@ -12,8 +12,6 @@ import type { ViewManagerContext } from './view-manager.js';
 export interface ViewSlot {
     /** The live WebContentsView for this slot, or null when not yet created. */
     getView(): WebContentsView | null;
-    /** Record whether the view is currently added to the contentView. */
-    setAdded?(added: boolean): void;
     /**
      * When true, force the desired placement to hidden — the view-creation site
      * has not produced the WCV yet, so the reconciler must never record an attach
@@ -21,12 +19,6 @@ export interface ViewSlot {
      * to re-open the gate.
      */
     gateHidden?(): boolean;
-    /**
-     * Run before the generic attach. Return true when the slot fully handled the
-     * attach itself (e.g. a lazy async load that adds the view on completion), so
-     * the reconciler must NOT addChildView here.
-     */
-    beforeAttach?(): boolean;
     /** Lazily create the view on attach (host-toolbar); used instead of getView. */
     ensureView?(): WebContentsView | null;
     /** Domain-specific setBounds (simulator zoom rides here). */
@@ -44,8 +36,10 @@ export interface ViewSlot {
  * settings/popover are main-owned and live in `overlayDesired`. Any change
  * merges the two, runs the pure reconcile core, and applies the ordered ops
  * through `viewTarget`. `epochCounter` is a single monotonic tick — main is the
- * only (serial) reconcile caller, so the core's stale guard passes by
- * construction; `rendererGeneration` still drives the reset on renderer restart.
+ * only (serial) reconcile caller, so the core's stale-epoch guard passes by
+ * construction; `rendererGeneration` is the high-water mark that drives both
+ * the reset on a genuinely newer generation and the hard rejection of a
+ * snapshot from behind it (see `setPlacementSnapshot`).
  */
 export interface PlacementReconciler {
     registerView(viewId: string, slot: ViewSlot): void;
@@ -55,19 +49,25 @@ export interface PlacementReconciler {
      * truth for every managed native view's bounds/visibility/z-order.
      */
     setPlacementSnapshot(snapshot: PlacementSnapshot<DevtoolsExtra>): void;
-    /**
-     * Forget a view's reconciled mount state so the NEXT rebuilt view is treated
-     * as a fresh attach. Required wherever a view instance is replaced/destroyed
-     * via a manual removeChildView that bypasses the reconciler (otherwise the
-     * level-triggered core still records the old instance as attached and never
-     * emits the attach op for the replacement — a sticky invisible view).
-     */
-    forgetActual(viewId: string): void;
+    /** Size a detached view for renderer-side intrinsic measurement. */
+    prepareView(viewId: string, view: WebContentsView, bounds: layout.Bounds): void;
+    /** Detach and close one concrete view instance through the native-tree owner. */
+    destroyView(viewId: string, view: WebContentsView | null): void;
     setBaseDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteBaseDesired(viewId: string): void;
     setOverlayDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteOverlayDesired(viewId: string): void;
     hasOverlayDesired(viewId: string): boolean;
+    /**
+     * Hand out a fresh generation seed for a renderer bootstrap (see
+     * renderer-placement-generation.ts). Strictly exceeds both the current
+     * high-water mark (`rendererGeneration`, which a full renderer reload does
+     * NOT reset — this reconciler lives in the long-lived main process) and
+     * every previously allocated seed, so a reload that races ahead of its own
+     * previous session's accepted snapshots can never be handed a value that
+     * `setPlacementSnapshot` would reject as stale.
+     */
+    allocateGeneration(): number;
 }
 export declare function createPlacementReconciler(ctx: ViewManagerContext): PlacementReconciler;
 //# sourceMappingURL=placement-reconciler.d.ts.map

package/dist/main/services/views/placement-reconciler.js

@@ -1,12 +1,18 @@
 import { reconcile, createInitialState } from '@dimina-kit/electron-deck/layout';
 import { applyViewOps } from './apply-view-ops.js';
+import { createNativeViewTreeHost } from './native-view-tree.js';
 export function createPlacementReconciler(ctx) {
     let placementState = createInitialState();
     let epochCounter = 0;
     let rendererGeneration = 0;
+    let allocatedGeneration = 0;
+    const appliedActual = new Map();
     const baseDesired = new Map();
     const overlayDesired = new Map();
     const slots = new Map();
+    // Sole owner of the main window's native child tree. Every attach, detach,
+    // reorder and hard destroy passes through this ledger-backed adapter.
+    const contentViewHost = createNativeViewTreeHost(ctx, slots);
     function gateReadiness(v) {
         const slot = slots.get(v.viewId);
         if (slot?.gateHidden?.())
@@ -20,59 +26,67 @@ export function createPlacementReconciler(ctx) {
             const slot = slots.get(viewId);
             if (!slot)
                 return;
-            if (slot.beforeAttach?.())
-                return;
             const view = slot.ensureView ? slot.ensureView() : slot.getView();
             if (!view)
                 return;
-            ctx.windows.mainWindow.contentView.addChildView(view);
-            slot.setAdded?.(true);
+            if (!contentViewHost.addChildView({ id: viewId }))
+                return;
+            const previous = appliedActual.get(viewId);
+            appliedActual.set(viewId, {
+                attached: true,
+                visible: true,
+                bounds: previous?.bounds,
+                extra: previous?.extra,
+            });
         },
         detach(viewId) {
-            const slot = slots.get(viewId);
-            const view = slot?.getView() ?? null;
-            if (view && !ctx.windows.mainWindow.isDestroyed()) {
-                try {
-                    ctx.windows.mainWindow.contentView.removeChildView(view);
-                }
-                catch { /* already removed */ }
-            }
-            slot?.setAdded?.(false);
+            if (!contentViewHost.removeChildView({ id: viewId }))
+                return;
+            appliedActual.delete(viewId);
         },
         setBounds(viewId, bounds, extra) {
             const slot = slots.get(viewId);
             const view = slot?.getView() ?? null;
             if (!view || view.webContents.isDestroyed())
                 return;
-            if (slot?.applyBounds) {
-                slot.applyBounds(view, bounds, extra);
+            try {
+                if (slot?.applyBounds)
+                    slot.applyBounds(view, bounds, extra);
+                else
+                    view.setBounds(bounds);
+            }
+            catch {
                 return;
             }
-            view.setBounds(bounds);
+            const previous = appliedActual.get(viewId);
+            appliedActual.set(viewId, {
+                attached: previous?.attached ?? false,
+                visible: previous?.visible ?? false,
+                bounds,
+                extra,
+            });
         },
         setVisible(viewId, visible) {
             const view = slots.get(viewId)?.getView() ?? null;
-            if (!view)
+            if (!view || view.webContents.isDestroyed())
                 return;
             try {
                 view.setVisible(visible);
             }
-            catch { /* stub may lack setVisible */ }
+            catch {
+                return;
+            }
+            const previous = appliedActual.get(viewId);
+            if (!previous)
+                return;
+            appliedActual.set(viewId, { ...previous, visible });
         },
         reorder(order) {
             // A single attached view is already in place — nothing to reorder.
             if (order.length <= 1 || ctx.windows.mainWindow.isDestroyed())
                 return;
-            const cv = ctx.windows.mainWindow.contentView;
-            for (const viewId of order) {
-                const view = slots.get(viewId)?.getView() ?? null;
-                if (view) {
-                    try {
-                        cv.addChildView(view);
-                    }
-                    catch { /* already attached */ }
-                }
-            }
+            for (const viewId of order)
+                contentViewHost.addChildView({ id: viewId });
         },
     };
     // Create the lazily-built views (host-toolbar, workbench) BEFORE reconcile so
@@ -83,6 +97,9 @@ export function createPlacementReconciler(ctx) {
             slot.ensureLazy?.(baseDesired.get(viewId));
         }
     }
+    function cloneAppliedActual() {
+        return new Map([...appliedActual].map(([viewId, actual]) => [viewId, { ...actual }]));
+    }
     function reconcileNow() {
         ensureLazyViews();
         const views = [];
@@ -90,6 +107,7 @@ export function createPlacementReconciler(ctx) {
             views.push(gateReadiness(v));
         for (const v of overlayDesired.values())
             views.push(v);
+        placementState = { ...placementState, actual: cloneAppliedActual() };
         const result = reconcile(placementState, {
             generation: rendererGeneration,
             epoch: ++epochCounter,
@@ -97,8 +115,33 @@ export function createPlacementReconciler(ctx) {
         });
         placementState = result.state;
         applyViewOps(result.ops, viewTarget);
+        // The planner's next state is optimistic. Keep only desired/epoch metadata;
+        // appliedActual is updated by successful native effects above.
+        placementState = { ...placementState, actual: cloneAppliedActual() };
     }
     function setPlacementSnapshot(snapshot) {
+        // Hard reject a snapshot from BEHIND the current high-water mark — a
+        // complete no-op, touching neither `rendererGeneration` nor
+        // `baseDesired`. The renderer hands out one shared, strictly monotonic
+        // sequence across every screen (see renderer-placement-generation.ts),
+        // so under normal operation a lower generation can only be a LATE
+        // arrival from an already-superseded source (e.g. a dead screen's
+        // delayed `dispose()` empty-snapshot flush racing a successor screen's
+        // mount). The previous version of this guard clamped
+        // `rendererGeneration` to never regress but still unconditionally
+        // applied the stale snapshot's CONTENT into `baseDesired` under the
+        // clamped (i.e. current) generation number — which defeated the
+        // reconcile core's own generation-regression guard
+        // (placement-reconcile.ts: `snapshot.generation < prev.generation`) by
+        // never letting it see the snapshot's real, lower generation. That let a
+        // dead screen's stale/empty view list silently overwrite a currently
+        // active screen's real views. Dropping it here, before it ever reaches
+        // `baseDesired`, is what actually gives the stale snapshot zero side
+        // effects.
+        if (snapshot.generation < rendererGeneration) {
+            console.warn(`[placement-reconciler] snapshot generation ${snapshot.generation} is behind the current ${rendererGeneration}; dropping without applying its content`);
+            return;
+        }
         rendererGeneration = snapshot.generation;
         baseDesired.clear();
         for (const v of snapshot.views)
@@ -109,12 +152,31 @@ export function createPlacementReconciler(ctx) {
         registerView: (viewId, slot) => { slots.set(viewId, slot); },
         reconcileNow,
         setPlacementSnapshot,
-        forgetActual: (viewId) => { placementState.actual.delete(viewId); },
+        prepareView: (viewId, view, bounds) => {
+            if (slots.get(viewId)?.getView() !== view || view.webContents.isDestroyed())
+                return;
+            try {
+                view.setBounds(bounds);
+            }
+            catch {
+                return;
+            }
+            appliedActual.set(viewId, { attached: false, visible: false, bounds });
+        },
+        destroyView: (viewId, view) => {
+            contentViewHost.destroyView(viewId, view);
+            appliedActual.delete(viewId);
+            placementState.actual.delete(viewId);
+        },
         setBaseDesired: (viewId, desired) => { baseDesired.set(viewId, desired); },
         deleteBaseDesired: (viewId) => { baseDesired.delete(viewId); },
         setOverlayDesired: (viewId, desired) => { overlayDesired.set(viewId, desired); },
         deleteOverlayDesired: (viewId) => { overlayDesired.delete(viewId); },
         hasOverlayDesired: (viewId) => overlayDesired.has(viewId),
+        allocateGeneration: () => {
+            allocatedGeneration = Math.max(allocatedGeneration, rendererGeneration) + 1;
+            return allocatedGeneration;
+        },
     };
 }
 //# sourceMappingURL=placement-reconciler.js.map