@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

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

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

@@ -13,9 +13,36 @@ interface SnapshotSink {
         views: DesiredView<DevtoolsExtra>[];
     }): void;
 }
+interface OverlaySink {
+    showSettings(): Promise<void>;
+    showPopover(data: unknown): void;
+    showTooltip(data: {
+        anchor: Rect;
+        text: string;
+    }): void;
+    getSettingsWebContentsId(): number | null;
+    getPopoverWebContentsId(): number | null;
+    getTooltipWebContentsId(): number | null;
+    markOverlayReady(webContentsId: number): void;
+    applyTooltipMeasurement(webContentsId: number, measurement: {
+        requestId: number;
+        width: number;
+        height: number;
+    }): void;
+}
 export declare function hostToolbarBounds(mgr: SnapshotSink, rect: Rect): void;
+export declare function hostSidebarBounds(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 showSettingsReady(mgr: OverlaySink): Promise<void>;
+export declare function showPopoverReady(mgr: OverlaySink, data: unknown): void;
+export declare function showTooltipReady(mgr: OverlaySink, data: {
+    anchor: Rect;
+    text: string;
+}, size?: {
+    width: number;
+    height: number;
+}): void;
 export declare function simulatorBounds(mgr: SnapshotSink, params: Rect & {
     zoom: number;
 }): void;

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

@@ -12,6 +12,7 @@ import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
 // pushes on one manager never look stale.
 let globalEpoch = 0;
 const desiredByMgr = new WeakMap();
+const tooltipRequestByMgr = new WeakMap();
 function toPlacement(r) {
     return r.width > 0 && r.height > 0 ? { visible: true, bounds: r } : { visible: false };
 }
@@ -27,12 +28,40 @@ function pushView(mgr, view, generation = 1) {
 export function hostToolbarBounds(mgr, rect) {
     pushView(mgr, { viewId: VIEW_ID.hostToolbar, placement: toPlacement(rect), layer: VIEW_LAYER.hostToolbar });
 }
+export function hostSidebarBounds(mgr, rect) {
+    pushView(mgr, { viewId: VIEW_ID.hostSidebar, placement: toPlacement(rect), layer: VIEW_LAYER.hostSidebar });
+}
 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 async function showSettingsReady(mgr) {
+    const shown = mgr.showSettings();
+    const webContentsId = mgr.getSettingsWebContentsId();
+    if (webContentsId === null)
+        throw new Error('settings view was not created');
+    mgr.markOverlayReady(webContentsId);
+    await shown;
+}
+export function showPopoverReady(mgr, data) {
+    mgr.showPopover(data);
+    const webContentsId = mgr.getPopoverWebContentsId();
+    if (webContentsId === null)
+        throw new Error('popover view was not created');
+    mgr.markOverlayReady(webContentsId);
+}
+export function showTooltipReady(mgr, data, size = { width: 80, height: 28 }) {
+    mgr.showTooltip(data);
+    const webContentsId = mgr.getTooltipWebContentsId();
+    if (webContentsId === null)
+        throw new Error('tooltip view was not created');
+    mgr.markOverlayReady(webContentsId);
+    const requestId = (tooltipRequestByMgr.get(mgr) ?? 0) + 1;
+    tooltipRequestByMgr.set(mgr, requestId);
+    mgr.applyTooltipMeasurement(webContentsId, { requestId, ...size });
+}
 export function simulatorBounds(mgr, params) {
     const { zoom, ...rect } = params;
     pushView(mgr, { viewId: VIEW_ID.simulator, placement: toPlacement(rect), layer: VIEW_LAYER.base, extra: { zoom } });

package/dist/main/services/views/refresh-styles.d.ts

@@ -0,0 +1,10 @@
+import { type WebContentsView } from 'electron';
+/**
+ * Hot-swap the stylesheets of every live render-host guest of `view` in place
+ * (no shell respawn — page stack / form state / scroll / focus survive). Guests
+ * are found via `hostWebContents === view.webContents` — the same nesting
+ * pattern the zoom propagation uses. Returns false when no live guest is found,
+ * so the caller can fall back to a full reload rather than dropping the edit.
+ */
+export declare function refreshGuestStylesheets(view: WebContentsView): boolean;
+//# sourceMappingURL=refresh-styles.d.ts.map

package/dist/main/services/views/refresh-styles.js

@@ -0,0 +1,57 @@
+import { webContents } from 'electron';
+/**
+ * Injected into each live render-host guest to hot-swap its stylesheets in
+ * place: for every `<link rel=stylesheet>`, insert a cache-busted clone
+ * (`?__hmr=<ts>`) so the browser re-fetches the recompiled `.css` and re-applies
+ * it against the already-mounted DOM, then drop the stale sheet once the fresh
+ * one loads (no unstyled flash). Recurses into same-origin iframes because a
+ * render-host page nests its content in an iframe. Self-contained (runs in the
+ * guest realm via `executeJavaScript`), defensive (never throws). Mirrors
+ * `@dimina-kit/devkit`'s `refreshStylesheets` (the SSE web-preview equivalent).
+ */
+const REFRESH_STYLES_JS = `(function refresh(doc){
+  try {
+    var links = doc.querySelectorAll('link[rel="stylesheet"]');
+    for (var i = 0; i < links.length; i++) {
+      var link = links[i];
+      try {
+        var u = new URL(link.href, doc.baseURI || undefined);
+        u.searchParams.set('__hmr', String(Date.now()));
+        var next = link.cloneNode();
+        next.href = u.href;
+        next.addEventListener('load', (function(stale){ return function(){ stale.remove(); }; })(link));
+        link.parentNode.insertBefore(next, link.nextSibling);
+      } catch (e) {}
+    }
+    var frames = doc.querySelectorAll('iframe');
+    for (var j = 0; j < frames.length; j++) {
+      try { if (frames[j].contentDocument) refresh(frames[j].contentDocument); } catch (e) {}
+    }
+  } catch (e) {}
+})(document);`;
+/**
+ * Hot-swap the stylesheets of every live render-host guest of `view` in place
+ * (no shell respawn — page stack / form state / scroll / focus survive). Guests
+ * are found via `hostWebContents === view.webContents` — the same nesting
+ * pattern the zoom propagation uses. Returns false when no live guest is found,
+ * so the caller can fall back to a full reload rather than dropping the edit.
+ */
+export function refreshGuestStylesheets(view) {
+    const simWc = view.webContents;
+    let refreshed = 0;
+    try {
+        for (const wc of webContents.getAllWebContents()) {
+            if (wc.isDestroyed())
+                continue;
+            if (wc.hostWebContents !== simWc)
+                continue;
+            wc.executeJavaScript(REFRESH_STYLES_JS).catch(() => { });
+            refreshed++;
+        }
+    }
+    catch {
+        return false;
+    }
+    return refreshed > 0;
+}
+//# sourceMappingURL=refresh-styles.js.map

package/dist/main/services/views/simulator-session-policy.d.ts

@@ -1,28 +1,2 @@
-/**
- * Referer + CORS webRequest policy for the simulator runtime's sessions.
- *
- * The native render/service hosts fetch the compiled `<appId>/…` resources
- * cross-origin and need a WeChat-style page-frame `Referer`; this installs that
- * policy on the shared fallback session AND on every per-project
- * `persist:miniapp-<key>` partition (current + future) via the partition
- * configurator registry, so isolated projects load resources identically.
- *
- * TEARDOWN: a `webRequest` listener is per-session and there is exactly one
- * slot per (session, event) — re-installing replaces, never stacks. But the
- * configurator registration itself leaks if discarded: re-creating the
- * WorkbenchApp in the same process would register a second configurator that
- * keeps firing for every future partition. So this returns a {@link Disposable}
- * that unregisters the configurator AND clears the listeners off every session
- * it touched. Wire it into the context registry like any other module.
- */
-import { type Disposable } from '@dimina-kit/electron-deck/main';
-/**
- * Install the simulator referer/CORS policy on the shared fallback session and
- * register a configurator so every per-project partition session gets it too.
- * Returns a disposable that unregisters the configurator and clears the policy
- * off every session it installed on — call its teardown when the owning
- * context is disposed so re-creating the app never leaks a duplicate
- * configurator/listener.
- */
-export declare function setupSimulatorSessionPolicy(): Disposable;
+export * from '@dimina-kit/electron-runtime/main/session-policy';
 //# sourceMappingURL=simulator-session-policy.d.ts.map

package/dist/main/services/views/simulator-session-policy.js

@@ -1,99 +1,2 @@
-/**
- * Referer + CORS webRequest policy for the simulator runtime's sessions.
- *
- * The native render/service hosts fetch the compiled `<appId>/…` resources
- * cross-origin and need a WeChat-style page-frame `Referer`; this installs that
- * policy on the shared fallback session AND on every per-project
- * `persist:miniapp-<key>` partition (current + future) via the partition
- * configurator registry, so isolated projects load resources identically.
- *
- * TEARDOWN: a `webRequest` listener is per-session and there is exactly one
- * slot per (session, event) — re-installing replaces, never stacks. But the
- * configurator registration itself leaks if discarded: re-creating the
- * WorkbenchApp in the same process would register a second configurator that
- * keeps firing for every future partition. So this returns a {@link Disposable}
- * that unregisters the configurator AND clears the listeners off every session
- * it touched. Wire it into the context registry like any other module.
- */
-import { session } from 'electron';
-import { toDisposable } from '@dimina-kit/electron-deck/main';
-import { getSimulatorServicewechatReferer } from '../simulator/referer.js';
-import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from './miniapp-partition.js';
-/** The response headers this policy owns outright (compared lowercase). */
-const CORS_OVERRIDE_HEADERS = new Set([
-    'access-control-allow-origin',
-    'access-control-allow-headers',
-    'access-control-allow-methods',
-]);
-/** Apply the simulator runtime's referer + CORS webRequest policy to one
- * session. Each session installs its own listeners (a webRequest listener is
- * per-session), so this runs once per partition. */
-function applySimulatorWebRequestPolicy(simulatorSession) {
-    simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
-        const forcedReferer = getSimulatorServicewechatReferer();
-        if (forcedReferer) {
-            details.requestHeaders['Referer'] = forcedReferer;
-        }
-        callback({ requestHeaders: details.requestHeaders });
-    });
-    simulatorSession.webRequest.onHeadersReceived((details, callback) => {
-        const headers = details.responseHeaders ?? {};
-        // CORS for the native render/service hosts to fetch compiled app resources
-        // cross-origin. (The COOP/COEP cross-origin-isolation headers were only for
-        // the removed default-path SharedArrayBuffer sync Worker — dropped.)
-        //
-        // This policy is the single authority for these three headers: any value
-        // the server itself sent must be REPLACED, not shadowed. responseHeaders
-        // keys keep the server's original casing, so assigning the lowercase key
-        // beside an existing `Access-Control-Allow-Origin` puts BOTH on the wire —
-        // Chromium then rejects the response for carrying multiple ACAO values
-        // (`*, *`), breaking every fetch against a CORS-compliant backend.
-        for (const key of Object.keys(headers)) {
-            if (CORS_OVERRIDE_HEADERS.has(key.toLowerCase()))
-                delete headers[key];
-        }
-        headers['access-control-allow-origin'] = ['*'];
-        headers['access-control-allow-headers'] = ['*'];
-        headers['access-control-allow-methods'] = ['*'];
-        callback({ responseHeaders: headers });
-    });
-}
-/** Remove the policy listeners from a session (passing `null` clears the slot). */
-function clearSimulatorWebRequestPolicy(simulatorSession) {
-    try {
-        simulatorSession.webRequest.onBeforeSendHeaders(null);
-        simulatorSession.webRequest.onHeadersReceived(null);
-    }
-    catch {
-        // Session already gone (app shutdown) — nothing to clear.
-    }
-}
-/**
- * Install the simulator referer/CORS policy on the shared fallback session and
- * register a configurator so every per-project partition session gets it too.
- * Returns a disposable that unregisters the configurator and clears the policy
- * off every session it installed on — call its teardown when the owning
- * context is disposed so re-creating the app never leaks a duplicate
- * configurator/listener.
- */
-export function setupSimulatorSessionPolicy() {
-    const configured = new Set();
-    function install(sess) {
-        if (configured.has(sess))
-            return;
-        configured.add(sess);
-        applySimulatorWebRequestPolicy(sess);
-    }
-    // Shared fallback session (pre-warm pool + unknown-appId path).
-    install(session.fromPartition(SHARED_MINIAPP_PARTITION));
-    // Every per-project miniapp partition session (current + future) gets the
-    // same referer/CORS policy so isolated projects load resources identically.
-    const unregister = registerMiniappSessionConfigurator((sess) => install(sess));
-    return toDisposable(() => {
-        unregister();
-        for (const sess of configured)
-            clearSimulatorWebRequestPolicy(sess);
-        configured.clear();
-    });
-}
+export * from '@dimina-kit/electron-runtime/main/session-policy';
 //# sourceMappingURL=simulator-session-policy.js.map

package/dist/main/services/views/view-manager-devtools-host-test-fixtures.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared harness for the simulator-DevTools host suites
+ * (`view-manager-devtools-host-repoint.test.ts` +
+ * `view-manager-service-host-ready.test.ts`), split out so each test file
+ * stays under the repo's 500-line-per-file ratchet. Pure test scaffolding,
+ * not code under test — same pattern as
+ * network-forward/global-mirror-test-fixtures.ts.
+ *
+ * Consumers register the module mocks themselves (vi.mock factories are
+ * hoisted per test file, so they live there, thin):
+ *   vi.mock('electron', async () =>
+ *     (await import('./view-manager-devtools-host-test-fixtures.js')).electronModuleMock())
+ *   vi.mock('../../utils/paths.js', async () =>
+ *     (await import('./view-manager-devtools-host-test-fixtures.js')).pathsModuleMock())
+ * The electron factory closes over this module's `constructed` /
+ * `serviceWcRegistry` registries, so test assertions and the mock see the
+ * same objects (vitest gives each test FILE its own instance of this module —
+ * no cross-file bleed).
+ */
+import { vi } from 'vitest';
+import type { RenderEvent, ServiceHostReadyEvent } from '../../ipc/bridge-router.js';
+import type { ViewManagerContext } from './view-manager.js';
+export type StubWebContents = {
+    destroyed: boolean;
+    id: number;
+    isDestroyed: () => boolean;
+    close: ReturnType<typeof vi.fn>;
+    loadURL: ReturnType<typeof vi.fn>;
+    loadFile: ReturnType<typeof vi.fn>;
+    on: ReturnType<typeof vi.fn>;
+    once: ReturnType<typeof vi.fn>;
+    removeListener: ReturnType<typeof vi.fn>;
+    setWindowOpenHandler: ReturnType<typeof vi.fn>;
+    setZoomFactor: ReturnType<typeof vi.fn>;
+    send: ReturnType<typeof vi.fn>;
+    setMaxListeners: ReturnType<typeof vi.fn>;
+    getMaxListeners: ReturnType<typeof vi.fn>;
+    isLoading: ReturnType<typeof vi.fn>;
+    executeJavaScript: ReturnType<typeof vi.fn>;
+    setDevToolsWebContents: ReturnType<typeof vi.fn>;
+    openDevTools: ReturnType<typeof vi.fn>;
+    isDevToolsOpened: ReturnType<typeof vi.fn>;
+    closeDevTools: ReturnType<typeof vi.fn>;
+    getURL: ReturnType<typeof vi.fn>;
+};
+export type StubView = {
+    webContents: StubWebContents;
+    setBounds: ReturnType<typeof vi.fn>;
+    setBackgroundColor: ReturnType<typeof vi.fn>;
+};
+/** Every WebContentsView ever constructed by the code under test, in
+ * construction order: attachNativeSimulator builds [0] = the native simulator
+ * content view, then attachNativeSimulatorDevtoolsHost builds [1] = the
+ * DevTools front-end host view. Reset in each file's beforeEach. */
+export declare const constructed: StubView[];
+/** Service-host wcs registered by `makeServiceWc`, looked up by
+ * `electron.webContents.fromId` — mirrors real Electron's global wc registry
+ * so `onNativeServiceHostReady`'s `webContents.fromId(event.serviceWcId)`
+ * resolution has something real to find. */
+export declare const serviceWcRegistry: Map<number, StubWebContents>;
+/** The `electron` module surface view-manager and its injectors touch. */
+export declare function electronModuleMock(): Record<string, unknown>;
+export declare function pathsModuleMock(): Record<string, unknown>;
+export declare const SIM_URL = "http://localhost:7788/simulator.html?appId=repoint";
+/** A hidden SERVICE-HOST BrowserWindow wc (top-level, can host DevTools). */
+export declare function makeServiceWc(id: number): StubWebContents;
+export interface DevtoolsHostHarness {
+    addChildView: ReturnType<typeof vi.fn>;
+    removeChildView: ReturnType<typeof vi.fn>;
+    setActiveServiceWc: (wc: StubWebContents) => void;
+    emitRenderEvent: (event: RenderEvent) => void;
+    emitServiceHostReady: (event: ServiceHostReadyEvent) => void;
+    ctx: ViewManagerContext;
+}
+export declare function makeContext(): DevtoolsHostHarness;
+//# sourceMappingURL=view-manager-devtools-host-test-fixtures.d.ts.map