@dimina-kit/devtools 0.4.0-dev.20260630123203 → 0.4.0-dev.20260701155140

package/dist/main/ipc/bridge-router.d.ts

@@ -12,12 +12,13 @@ import type { DebugTap } from '@dimina-kit/electron-deck/main';
  */
 /**
  * Render-side activity worth re-reading panel data on: a page's DOM mounted
- * (`domReady`) or the visible page changed (`activePage`). Panels that pull
- * from the active render guest (WXML/element-inspect) subscribe via
- * `BridgeRouterHandle.onRenderEvent` so they can refresh without polling.
+ * (`domReady`), the visible page changed (`activePage`), or the active page's
+ * DOM mutated in place (`domMutated`, from the render-guest MutationObserver).
+ * Panels that pull from the active render guest (WXML/element-inspect) subscribe
+ * via `BridgeRouterHandle.onRenderEvent` so they can refresh without polling.
  */
 export interface RenderEvent {
-    kind: 'domReady' | 'activePage';
+    kind: 'domReady' | 'activePage' | 'domMutated';
     appId: string;
     bridgeId: string;
     /** activePage only: the now-visible page's route (bare pagePath), if known.

package/dist/main/ipc/bridge-router.js

@@ -583,6 +583,7 @@ async function handleSpawn(state, ctx, event, opts) {
         poolEntryId,
         onServiceClosed: null,
         onServiceBoot: null,
+        registryHandle: null,
     };
     const rootPage = {
         bridgeId,
@@ -617,7 +618,7 @@ async function handleSpawn(state, ctx, event, opts) {
             state.wcIdToAppSessionId.delete(appSession.serviceWc.id);
         }
     });
-    ctx.registry.add(() => disposeAppSession(state, appSessionId));
+    appSession.registryHandle = ctx.registry.add(() => disposeAppSession(state, appSessionId));
     const onServiceClosed = () => {
         void disposeAppSession(state, appSessionId, { serviceAlreadyClosed: true });
     };
@@ -977,6 +978,20 @@ function handleContainerMsg(ap, page, msg, ctx, state) {
             // Guarded + non-throwing: console capture must never break message routing.
             ctx.guestConsole?.emit(msg.body);
             break;
+        case 'storageChanged':
+            // Native-host SYNC storage liveness: the service-host's `setStorageSync`/etc.
+            // write `localStorage` directly (no main round-trip), so they post the change
+            // here for the Storage panel to stay live. Trust `ap.appId` (sender-resolved),
+            // not any appId in the body. Guarded + non-throwing.
+            ctx.onServiceStorageChanged?.(ap.appId, msg.body);
+            break;
+        case 'wxmlChanged':
+            // Native-host WXML liveness: the render-guest MutationObserver posts this when
+            // the active page's DOM mutated in place (setData). Surface it as a render
+            // event so the WXML panel service re-pulls + pushes — same pipeline as
+            // domReady/activePage. Trust `page.bridgeId` (sender-resolved), not the body.
+            state.emitRenderEvent({ kind: 'domMutated', appId: ap.appId, bridgeId: page.bridgeId });
+            break;
         default:
             break;
     }
@@ -1428,6 +1443,15 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     if (!ap)
         return;
     state.appSessions.delete(appSessionId);
+    // Remove this session's shutdown-fallback registry entry so the registry does
+    // not accumulate one stale closure per respawn. Ordered AFTER the delete
+    // above: dispose() runs the wrapped fn (disposeAppSession again), which
+    // early-returns now that the session is gone — no recursion, no double-run.
+    // (At whole-app shutdown the registry marks the entry released before calling
+    // the fn, so this dispose() is a no-op then.)
+    const registryHandle = ap.registryHandle;
+    ap.registryHandle = null;
+    void registryHandle?.dispose();
     state.appLifecycle.dispose(appSessionId);
     // Evict AppData bridges FIRST — eviction enumerates `ap.pages`, which the
     // page teardown below progressively empties (and finally clears).

package/dist/main/ipc/simulator.js

@@ -1,5 +1,5 @@
 import { ServiceHostChannel, SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
-import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorSetDeviceInfoSchema, SimulatorSetNativeBoundsSchema, } from '../../shared/ipc-schemas.js';
+import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorSetDeviceInfoSchema, } from '../../shared/ipc-schemas.js';
 import { deviceInfoToHostEnv } from '../../shared/bridge-channels.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
@@ -11,10 +11,6 @@ export function registerSimulatorIpc(ctx) {
     })
         .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();
-    })
-        .handle(SimulatorChannel.SetNativeBounds, (_, ...args) => {
-        const [p] = validate(SimulatorChannel.SetNativeBounds, SimulatorSetNativeBoundsSchema, args);
-        ctx.views.setNativeSimulatorViewBounds(p);
     })
         .handle(SimulatorChannel.SetDeviceInfo, (_, ...args) => {
         const [device] = validate(SimulatorChannel.SetDeviceInfo, SimulatorSetDeviceInfoSchema, args);

package/dist/main/ipc/views.js

@@ -1,6 +1,6 @@
 import { ipcMain } from 'electron';
 import { ViewChannel } from '../../shared/ipc-channels.js';
-import { ViewBoundsSchema, HostToolbarAdvertiseHeightSchema, } from '../../shared/ipc-schemas.js';
+import { PlacementSnapshotSchema, HostToolbarAdvertiseHeightSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 /**
@@ -20,24 +20,13 @@ import { IpcRegistry } from '../utils/ipc-registry.js';
  */
 export function registerViewsIpc(ctx) {
     const registry = new IpcRegistry(ctx.senderPolicy)
-        .handle(ViewChannel.SimulatorDevtoolsBounds, (_event, ...args) => {
-        const [bounds] = validate(ViewChannel.SimulatorDevtoolsBounds, ViewBoundsSchema, args);
-        ctx.views.setSimulatorDevtoolsBounds(bounds);
-    })
-        // Embedded workbench editor: forward anchor (the MAIN renderer measures
-        // the 'editor' dock slot rect → workbench WCV bounds). invoke, mirroring
-        // SimulatorDevtoolsBounds. No-op in the view manager when the workbench view
-        // was never attached (the host did not opt into the workbench editor).
-        .handle(ViewChannel.WorkbenchBounds, (_event, ...args) => {
-        const [bounds] = validate(ViewChannel.WorkbenchBounds, ViewBoundsSchema, args);
-        ctx.views.setWorkbenchBounds(bounds);
-    })
-        // Host-controllable toolbar: forward anchor (the MAIN renderer measures the
-        // placeholder rect → toolbar WCV bounds). invoke, mirroring
-        // SimulatorDevtoolsBounds. Sender is the trusted main renderer.
-        .handle(ViewChannel.HostToolbarBounds, (_event, ...args) => {
-        const [bounds] = validate(ViewChannel.HostToolbarBounds, ViewBoundsSchema, args);
-        ctx.views.setHostToolbarBounds(bounds);
+        // Window-level placement snapshot: the single source of truth for every
+        // managed native view's bounds/visibility/z-order. The renderer's central
+        // publisher coalesces one snapshot per frame; the reconciler diffs it
+        // against the actual view tree. Supersedes the per-view bounds channels.
+        .handle(ViewChannel.PlacementSnapshot, (_event, ...args) => {
+        const [snapshot] = validate(ViewChannel.PlacementSnapshot, PlacementSnapshotSchema, args);
+        ctx.views.setPlacementSnapshot(snapshot);
     })
         // Height replay pull: a freshly-mounted main-renderer placeholder asks for
         // the last NOTIFIED toolbar height (main retains it — the toolbar's

package/dist/main/services/automation/wait-active-page.d.ts

@@ -22,9 +22,11 @@
  *   - Resolve exactly once; later events are inert and the subscription is torn
  *     down on resolve.
  */
-/** The render-event shape `waitForActivePage` reads (subset of `RenderEvent`). */
+/** The render-event shape `waitForActivePage` reads (subset of `RenderEvent`).
+ * Only `activePage` events end the wait; other kinds (`domReady`/`domMutated`)
+ * are inert but included so a full `RenderEvent` is assignable here. */
 export interface ActivePageEventLike {
-    kind: 'domReady' | 'activePage';
+    kind: 'domReady' | 'activePage' | 'domMutated';
     appId: string;
     bridgeId: string;
     pagePath?: string;

package/dist/main/services/render-inspect/index.d.ts

@@ -24,6 +24,15 @@ export interface RenderInspector {
     highlight(wc: WebContents, sid: string): Promise<ElementInspection | null>;
     /** Clear any highlight overlay in the guest. */
     unhighlight(wc: WebContents): Promise<void>;
+    /**
+     * Toggle the guest-side WXML MutationObserver. When on, the injected IIFE
+     * watches `document.body` and posts a debounced `wxmlChanged` over
+     * `DiminaRenderBridge` on every DOM mutation (setData), which bridge-router
+     * turns into a `domMutated` render event so the WXML panel re-pulls. Only
+     * enabled while the WXML panel is visible, so an unseen panel never drives a
+     * full Vue-tree walk. Injects the IIFE first if needed; no-op on a dead guest.
+     */
+    setWxmlObserving(wc: WebContents, on: boolean): Promise<void>;
 }
 export interface RenderInspectorOptions {
     /** Override the injected IIFE source (default: read the built bundle). Test seam. */

package/dist/main/services/render-inspect/index.js

@@ -259,6 +259,18 @@ export function createRenderInspector(options = {}) {
             // best-effort
         }
     }
-    return { getWxml, highlight, unhighlight };
+    async function setWxmlObserving(wc, on) {
+        if (wc.isDestroyed())
+            return;
+        if (!(await ensureInjected(wc)))
+            return;
+        try {
+            await wc.executeJavaScript(`window.__diminaRenderInspect && window.__diminaRenderInspect.setWxmlObserving(${on ? 'true' : 'false'})`);
+        }
+        catch {
+            // best-effort: a guest mid-teardown just stops observing on its own.
+        }
+    }
+    return { getWxml, highlight, unhighlight, setWxmlObserving };
 }
 //# sourceMappingURL=index.js.map

package/dist/main/services/simulator-storage/index.d.ts

@@ -15,6 +15,7 @@
  */
 import { type WebContents } from 'electron';
 import { type ConnectionRegistry, type Disposable } from '@dimina-kit/electron-deck/main';
+import { type SyncStorageChange } from '../../../shared/ipc-channels.js';
 import { type SenderPolicy } from '../../utils/ipc-registry.js';
 import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
 import type { RenderInspector } from '../render-inspect/index.js';
@@ -34,6 +35,14 @@ export declare const STORAGE_API_NAMES: Set<string>;
 export interface SimulatorStorageHandle extends Disposable {
     /** Present only under native-host; wired to ctx.storageApi for bridge-router. */
     storageApi: StorageApi | null;
+    /**
+     * Native-host SYNC-storage liveness: bridge-router calls this on each
+     * `storageChanged` container message the service-host posts after a
+     * `setStorageSync`/`removeStorageSync`/`clearStorageSync`. Those write the
+     * service-host `localStorage` directly (bypassing main), so they'd otherwise
+     * leave the panel stale until reload — this pushes the matching `StorageEvent`.
+     */
+    onSyncStorageChange(appId: string, change: SyncStorageChange): void;
 }
 export interface SimulatorStorageOptions {
     /**

package/dist/main/services/simulator-storage/index.js

@@ -573,7 +573,32 @@ export function setupSimulatorStorage(host, options) {
     const storageApi = options.bridge?.isNativeHost()
         ? { invoke: runtimeInvoke }
         : null;
-    return { dispose: () => registry.dispose(), storageApi };
+    /**
+     * SYNC wx storage APIs run inside the service-host window and write
+     * `localStorage` directly, so they never reach `setItem`/`runtimeInvoke` here.
+     * The service-host posts the change over `DiminaServiceBridge` and bridge-router
+     * routes it here so the panel stays live. Only the ACTIVE app's changes are
+     * surfaced (the panel shows one app); the key already carries the `${appId}_`
+     * prefix, matching the CDP / async event shape.
+     */
+    function onSyncStorageChange(appId, change) {
+        if (appId !== getActiveAppId())
+            return;
+        if (host.isDestroyed())
+            return;
+        switch (change.op) {
+            case 'set':
+                pushSyntheticEvent({ type: 'added', key: change.key, newValue: change.value });
+                break;
+            case 'remove':
+                pushSyntheticEvent({ type: 'removed', key: change.key });
+                break;
+            case 'clear':
+                host.send(SimulatorStorageChannel.Event, { type: 'cleared' });
+                break;
+        }
+    }
+    return { dispose: () => registry.dispose(), storageApi, onSyncStorageChange };
 }
 // Element inspection delegates to the simulator preload's __simulatorData
 // bridge via executeJavaScript. Looked up independently from `attachedWc` so

package/dist/main/services/simulator-wxml/index.js

@@ -4,25 +4,131 @@ import { IpcRegistry } from '../../utils/ipc-registry.js';
 export function setupSimulatorWxml(host, options) {
     const { bridge, inspector, getActiveAppId } = options;
     const registry = new DisposableRegistry();
-    /** Read the WXML tree of the visible page of the active app, or null. */
-    async function pull() {
-        const wc = bridge.getActiveRenderWc(getActiveAppId() ?? undefined);
+    // Whether the WXML panel is currently visible (renderer drives this via
+    // SetActive). Live tree pushes + the render-guest DOM observer only run while
+    // active, so an unseen panel never triggers a full Vue-tree walk.
+    let active = false;
+    // latest-wins: only the newest pull's result is pushed (a slow walk that
+    // resolves after a newer one must not clobber the fresher tree).
+    let seq = 0;
+    // in-flight coalescing: at most one pull runs at a time; a request that lands
+    // mid-pull sets `again` so exactly one follow-up pull runs after it settles.
+    let pulling = false;
+    let again = false;
+    // The render guest currently being observed, so we can stop it on page change
+    // / deactivation (single owner).
+    let observedWc = null;
+    /** The visible page's render WebContents of the active app, or null. */
+    function activeWc() {
+        return bridge.getActiveRenderWc(getActiveAppId() ?? undefined);
+    }
+    /** Read the WXML tree of a render guest, or null when there is none. */
+    async function pull(wc) {
         if (!wc)
             return null;
         return inspector.getWxml(wc);
     }
+    /**
+     * Pull the active tree and push it, gated by `active` and reconciled by
+     * latest-wins + in-flight coalescing so a burst of render events (setData)
+     * collapses to a single fresh push instead of a pile of overlapping walks.
+     */
+    function schedulePull() {
+        if (!active)
+            return;
+        const mySeq = ++seq;
+        if (pulling) {
+            again = true;
+            return;
+        }
+        pulling = true;
+        void pull(activeWc())
+            .then((tree) => {
+            // Re-check `active` at send time: a pull started while visible must NOT
+            // push after the panel was hidden / disposed (deactivate bumps `seq`, so
+            // `mySeq === seq` also guards, but the explicit `active` check is the
+            // clear invariant).
+            if (mySeq === seq && active && !host.isDestroyed()) {
+                host.send(SimulatorWxmlChannel.Event, tree);
+            }
+        })
+            .finally(() => {
+            pulling = false;
+            if (again) {
+                again = false;
+                schedulePull();
+            }
+        });
+    }
+    function startObserving(wc) {
+        if (!wc)
+            return;
+        observedWc = wc;
+        // The guest IIFE defers observe() until document.body exists, so a wc whose
+        // DOM isn't up yet still starts observing once it loads — no retry needed here.
+        void inspector.setWxmlObserving(wc, true);
+    }
+    function stopObserving() {
+        const wc = observedWc;
+        observedWc = null;
+        if (wc)
+            void inspector.setWxmlObserving(wc, false);
+    }
+    /**
+     * Point the DOM observer at the CURRENT active render guest. Called on every
+     * render event while active, so the observer installs even when SetActive fired
+     * before the guest existed (the guest appears on `domReady`) and follows the
+     * active page across navigation (`activePage`).
+     */
+    function reconcileObserving() {
+        if (!active)
+            return;
+        const wc = activeWc();
+        if (wc !== observedWc) {
+            stopObserving();
+            startObserving(wc);
+        }
+    }
+    /** Invalidate any in-flight pull + queued re-pull so nothing pushes post-hide. */
+    function cancelPending() {
+        seq++;
+        again = false;
+    }
     const ipc = new IpcRegistry(options.senderPolicy);
-    ipc.handle(SimulatorWxmlChannel.GetSnapshot, () => pull());
+    ipc.handle(SimulatorWxmlChannel.GetSnapshot, () => pull(activeWc()));
+    ipc.handle(SimulatorWxmlChannel.SetActive, (_event, on) => {
+        if (on) {
+            active = true;
+            reconcileObserving();
+            schedulePull(); // seed the now-visible panel
+        }
+        else {
+            active = false;
+            cancelPending();
+            stopObserving();
+        }
+    });
     registry.add(ipc);
-    // Re-read + push when a page's DOM mounts or the visible page changes.
-    const unsubscribe = bridge.onRenderEvent(() => {
-        void pull().then((tree) => {
-            if (host.isDestroyed())
-                return;
-            host.send(SimulatorWxmlChannel.Event, tree);
-        });
+    // Re-read + push on render-side activity: a page's DOM mounted (`domReady`),
+    // the visible page changed (`activePage`), or the active page's DOM mutated in
+    // place (`domMutated`, from the render-guest observer). Gated by `active` and
+    // scoped to the ACTIVE app so a background app's / stale bridge's event never
+    // drives a spurious full walk of the visible page.
+    const unsubscribe = bridge.onRenderEvent((event) => {
+        if (!active)
+            return;
+        const appId = getActiveAppId();
+        if (appId && event.appId !== appId)
+            return;
+        // domReady: the guest may have just appeared → (re)install the observer.
+        // activePage: the active guest changed → move the observer.
+        // domMutated: same guest → reconcile is a no-op, then pull.
+        reconcileObserving();
+        schedulePull();
     });
     registry.add(unsubscribe);
+    // Stop observing + invalidate in-flight pulls on teardown (best-effort).
+    registry.add(() => { active = false; cancelPending(); stopObserving(); });
     return registry;
 }
 //# sourceMappingURL=index.js.map

package/dist/main/services/views/apply-view-ops.d.ts

@@ -0,0 +1,11 @@
+import type { Bounds, ViewOp } from '@dimina-kit/electron-deck/layout';
+import type { DevtoolsExtra } from '../../../shared/view-ids.js';
+export interface ViewOpTarget {
+    attach(viewId: string): void;
+    detach(viewId: string): void;
+    setBounds(viewId: string, bounds: Bounds, extra?: DevtoolsExtra): void;
+    setVisible(viewId: string, visible: boolean): void;
+    reorder(order: string[]): void;
+}
+export declare function applyViewOps(ops: ViewOp<DevtoolsExtra>[], target: ViewOpTarget): void;
+//# sourceMappingURL=apply-view-ops.d.ts.map

package/dist/main/services/views/apply-view-ops.js

@@ -0,0 +1,22 @@
+export function applyViewOps(ops, target) {
+    for (const op of ops) {
+        switch (op.kind) {
+            case 'detach':
+                target.detach(op.viewId);
+                break;
+            case 'setVisible':
+                target.setVisible(op.viewId, op.visible);
+                break;
+            case 'setBounds':
+                target.setBounds(op.viewId, op.bounds, op.extra);
+                break;
+            case 'attach':
+                target.attach(op.viewId);
+                break;
+            case 'reorder':
+                target.reorder(op.order);
+                break;
+        }
+    }
+}
+//# sourceMappingURL=apply-view-ops.js.map

package/dist/main/services/views/placement-test-driver.d.ts

@@ -0,0 +1,25 @@
+import type { DesiredView } from '@dimina-kit/electron-deck/layout';
+import { type DevtoolsExtra } from '../../../shared/view-ids.js';
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface SnapshotSink {
+    setPlacementSnapshot(snapshot: {
+        generation: number;
+        epoch: number;
+        views: DesiredView<DevtoolsExtra>[];
+    }): void;
+}
+export declare function hostToolbarBounds(mgr: SnapshotSink, rect: Rect): void;
+export declare function simulatorDevtoolsBounds(mgr: SnapshotSink, rect: Rect): void;
+export declare function workbenchBounds(mgr: SnapshotSink, rect: Rect): void;
+export declare function simulatorBounds(mgr: SnapshotSink, params: Rect & {
+    zoom: number;
+}): void;
+/** Drop a view from this manager's desired table (reconcile detaches it). */
+export declare function removeView(mgr: SnapshotSink, viewId: string): void;
+export {};
+//# sourceMappingURL=placement-test-driver.d.ts.map

package/dist/main/services/views/placement-test-driver.js

@@ -0,0 +1,48 @@
+// Test-only helper: drives the view manager through its real runtime entry
+// point, `setPlacementSnapshot`, the way the renderer's central publisher does
+// — accumulating each view's desired placement (per manager) and publishing the
+// WHOLE table under a monotonic epoch. A single-view update thus keeps the other
+// views' last-declared placement, matching the renderer's level-triggered stream
+// rather than the old per-view setXxxBounds edges. These free functions let the
+// many view-manager tests exercise reconcile behaviour with a drop-in rename
+// (`mgr.setHostToolbarBounds(r)` → `hostToolbarBounds(mgr, r)`).
+import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
+// Monotonic across every push in a test file (vitest isolates module state per
+// file), so a fresh manager (lastEpoch -1) accepts the first push and repeated
+// pushes on one manager never look stale.
+let globalEpoch = 0;
+const desiredByMgr = new WeakMap();
+function toPlacement(r) {
+    return r.width > 0 && r.height > 0 ? { visible: true, bounds: r } : { visible: false };
+}
+function pushView(mgr, view, generation = 1) {
+    let desired = desiredByMgr.get(mgr);
+    if (!desired) {
+        desired = new Map();
+        desiredByMgr.set(mgr, desired);
+    }
+    desired.set(view.viewId, view);
+    mgr.setPlacementSnapshot({ generation, epoch: globalEpoch++, views: [...desired.values()] });
+}
+export function hostToolbarBounds(mgr, rect) {
+    pushView(mgr, { viewId: VIEW_ID.hostToolbar, placement: toPlacement(rect), layer: VIEW_LAYER.hostToolbar });
+}
+export function simulatorDevtoolsBounds(mgr, rect) {
+    pushView(mgr, { viewId: VIEW_ID.simulatorDevtools, placement: toPlacement(rect), layer: VIEW_LAYER.base });
+}
+export function workbenchBounds(mgr, rect) {
+    pushView(mgr, { viewId: VIEW_ID.workbench, placement: toPlacement(rect), layer: VIEW_LAYER.base });
+}
+export function simulatorBounds(mgr, params) {
+    const { zoom, ...rect } = params;
+    pushView(mgr, { viewId: VIEW_ID.simulator, placement: toPlacement(rect), layer: VIEW_LAYER.base, extra: { zoom } });
+}
+/** Drop a view from this manager's desired table (reconcile detaches it). */
+export function removeView(mgr, viewId) {
+    const desired = desiredByMgr.get(mgr);
+    if (!desired)
+        return;
+    desired.delete(viewId);
+    mgr.setPlacementSnapshot({ generation: 1, epoch: globalEpoch++, views: [...desired.values()] });
+}
+//# sourceMappingURL=placement-test-driver.js.map

package/dist/main/services/views/view-manager.d.ts

@@ -3,6 +3,8 @@ import type { NativeDeviceInfo } from '../../../shared/ipc-channels.js';
 import { type OpenInEditorRequest } from '../../../shared/open-in-editor.js';
 import { type WorkbenchContext } from '../workbench-context.js';
 import { type HostToolbarMessageSubscription } from './host-toolbar-port-channel.js';
+import type { PlacementSnapshot } from '@dimina-kit/electron-deck/layout';
+import { type DevtoolsExtra } from '../../../shared/view-ids.js';
 /**
  * Context surface used by the ViewManager. We only need a small slice of the
  * full WorkbenchContext here; typing it this way documents the actual dependency.
@@ -11,10 +13,10 @@ export interface ViewManagerContext {
     windows: WorkbenchContext['windows'];
     rendererDir: string;
     /**
-     * Per-webContents connection registry (foundation.md §4). The native-host
+     * Per-webContents connection registry. The native-host
      * simulator WebContentsView is acquired here so the registry tracks that
      * trusted webContents and tears its per-wc resources (the custom-api bridge
-     * `ipcMain.on`) down deterministically on destroy — see P1 DoD #3. Required:
+     * `ipcMain.on`) down deterministically on destroy. Required:
      * `createWorkbenchContext` always supplies it.
      */
     connections: WorkbenchContext['connections'];
@@ -135,22 +137,6 @@ export interface ViewManager {
      * always on close-project → reopen) would otherwise be lost forever.
      */
     getHostToolbarHeight(): number;
-    /**
-     * NATIVE-HOST ONLY. Position the simulator content WebContentsView over the
-     * renderer-measured simulator panel REGION rect (the flex:1 placeholder slot,
-     * CSS px from the main window content top-left, which maps 1:1 to overlay
-     * setBounds DIP) and apply the device zoom. The WCV fills the region as a
-     * plain rectangle; DeviceShell draws + scrolls the phone inside. No-op in the
-     * default `<webview>` path (`nativeSimulatorView` is null). See
-     * `computeNativeSimulatorViewParams`.
-     */
-    setNativeSimulatorViewBounds(params: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        zoom: number;
-    }): void;
     /**
      * NATIVE-HOST ONLY. Re-push the selected device's CSS `env(safe-area-inset-*)`
      * override to every attached render-host guest (on device change). New guests
@@ -164,17 +150,12 @@ export interface ViewManager {
      */
     resize(simWidth: number): void;
     /**
-     * Apply a renderer-measured rectangle to the simulator's Chromium
-     * DevTools overlay view. `{ width: 0, height: 0 }` is treated as "hide" —
-     * the view is removed from the contentView but its WebContents is kept
-     * alive so re-showing it doesn't re-pay the DevTools bootstrap.
+     * Apply the renderer's window-level placement snapshot — the single source of
+     * truth for every managed native view's bounds/visibility/z-order. Merged with
+     * main-owned settings/popover desired state and reconciled against the actual
+     * view tree.
      */
-    setSimulatorDevtoolsBounds(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): void;
+    setPlacementSnapshot(snapshot: PlacementSnapshot<DevtoolsExtra>): void;
     /**
      * Lazily create the workbench WebContentsView, load `<url>index.html`, and
      * add it to the contentView. `url` is the COI server's base URL (trailing
@@ -188,19 +169,6 @@ export interface ViewManager {
      * `setWorkbenchBounds`, keeping it off the app boot critical path.
      */
     setWorkbenchSource(url: string): void;
-    /**
-     * Apply a renderer-measured rectangle to the workbench editor view. Mirrors
-     * `setSimulatorDevtoolsBounds`: `{ width: 0, height: 0 }` is "hide" — the view
-     * is removed from the contentView (kept under settings/popover when re-added)
-     * but its WebContents stays alive. The first non-zero rect lazily creates +
-     * loads the workbench (from the URL set by `setWorkbenchSource`).
-     */
-    setWorkbenchBounds(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): void;
     /** Destroy the workbench editor view (teardown). No-op if never attached. */
     detachWorkbench(): void;
     /**
@@ -211,20 +179,6 @@ export interface ViewManager {
      * request was dispatched to the workbench.
      */
     openFileInWorkbench(relPath: string, line: number, column: number): boolean;
-    /**
-     * Apply a renderer-measured rectangle to the host-controllable toolbar
-     * WebContentsView (the strip above the devtools header). Forward anchor,
-     * mirroring `setSimulatorDevtoolsBounds`. `{ width: 0, height: 0 }` is
-     * treated as "hide" — the view is removed from the contentView but its
-     * WebContents (and the host's loaded content) stays alive. Lazily creates
-     * the view on the first non-empty rect.
-     */
-    setHostToolbarBounds(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): void;
     /**
      * Reverse size-advertiser sink: the toolbar WCV's own renderer advertises
      * its intrinsic content height (block-axis extent); we retain it as the