@dimina-kit/devtools 0.4.0-dev.20260618090552 → 0.4.0-dev.20260624084417

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

@@ -453,7 +453,10 @@ async function handleSpawn(state, ctx, event, opts) {
     const appSessionId = bridgeId;
     const simulatorWc = resolveSimulatorWebContents(ctx, opts.simulatorWcId, event.sender);
     const pagePath = normalizePagePath(opts.pagePath || 'pages/index/index');
-    const pkgRoot = path.resolve(opts.pkgRoot || process.cwd());
+    const workspaceProjectPath = typeof ctx.workspace.getProjectPath === 'function'
+        ? ctx.workspace.getProjectPath()
+        : '';
+    const pkgRoot = path.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
     const root = opts.root || 'main';
     // Resource base resolution. Preferred: the simulator-supplied dev-server
     // origin, which statically serves the compiled `<appId>/<root>/…` tree (same
@@ -505,6 +508,7 @@ async function handleSpawn(state, ctx, event, opts) {
             appId,
             pagePath,
             pkgRoot,
+            root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
         });
@@ -608,6 +612,7 @@ async function handleSpawn(state, ctx, event, opts) {
             appId,
             pagePath,
             pkgRoot,
+            root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
         }));
@@ -1099,13 +1104,13 @@ function makeLoadResource(ap, page, target) {
             // dimina's service runtime reads hostEnv as `{ systemInfo, menuRect }`
             // (core/host-env.js init → getSystemInfo/getMenuRect; invokeAPI resolves
             // getSystemInfoSync/getWindowInfo/getDeviceInfo from hostEnv.systemInfo).
-            // We previously sent the FLAT HostEnvSnapshot, so `systemInfo` was null →
-            // `wx.getSystemInfoSync()` returned null and pages reading
-            // `.screenWidth` threw. Nest it under `systemInfo`. (render does NOT read
-            // hostEnv, so this is service-only; the devtools sync-api-patch reads the
-            // separate __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
-            // menuRect stays null as before — getMenuButtonBoundingClientRect is
-            // served by the sync-api-patch / DeviceShell capsule, not this path.
+            // The snapshot must be nested under `systemInfo`: a FLAT HostEnvSnapshot
+            // leaves `systemInfo` null → `wx.getSystemInfoSync()` returns null and
+            // pages reading `.screenWidth` throw. (render does NOT read hostEnv, so
+            // this is service-only; the devtools sync-api-patch reads the separate
+            // __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
+            // menuRect stays null — getMenuButtonBoundingClientRect is served by the
+            // sync-api-patch / DeviceShell capsule, not this path.
             hostEnv: { systemInfo: ap.hostEnv, menuRect: null },
         },
     };

package/dist/main/ipc/projects.js

@@ -49,7 +49,7 @@ export function registerProjectsIpc(ctx) {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
     })
-        // ── Phase 3: template catalog + create flow ──
+        // ── template catalog + create flow ──
         .handle(ProjectsChannel.ListTemplates, () => {
         // Sanitize at the IPC boundary: `generate` is a function and the
         // structured-clone algorithm Electron uses for invoke would otherwise

package/dist/main/ipc/simulator.js

@@ -7,7 +7,7 @@ export function registerSimulatorIpc(ctx) {
     return new IpcRegistry(ctx.senderPolicy)
         .handle(SimulatorChannel.AttachNative, (_, ...args) => {
         const [simulatorUrl, simWidth] = validate(SimulatorChannel.AttachNative, SimulatorAttachNativeSchema, args);
-        ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
+        return ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
     })
         .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();

package/dist/main/runtime/miniapp-runtime.d.ts

@@ -83,9 +83,9 @@ declare global {
     }
 }
 /**
- * Host-facing control surface for the toolbar WebContentsView — the exact
- * post-R2 message-channel surface (`send`/`onMessage`), with no `webContents`
- * escape hatch (that would put Electron types on the contract).
+ * Host-facing control surface for the toolbar WebContentsView — a
+ * message-channel surface (`send`/`onMessage`), with no `webContents` escape
+ * hatch (that would put Electron types on the contract).
  */
 export interface MiniappHostToolbar {
     /**

package/dist/main/services/elements-forward/index.js

@@ -36,7 +36,7 @@
  * no longer active is dropped (its in-flight command id is settled with an error
  * so the front-end never leaks a pending request, and stale nodes never bleed into
  * the new tree); and switching away and BACK to a previously-wired guest RESUMES
- * its forwarding (a snapshot would strand it — that was bug B2).
+ * its forwarding (a snapshot would strand it).
  *
  * ── Degradation ──────────────────────────────────────────────────────────────
  * Hook unavailable / `DevToolsAPI` missing / no active guest → routing is simply
@@ -46,7 +46,7 @@
  *
  * This is a production feature (no env gate, default on for the native simulator).
  * It deliberately re-implements the small pure helpers it needs (routing table,
- * hook + dispatch scripts) rather than importing the throwaway spike file.
+ * hook + dispatch scripts) as self-contained code.
  */
 import { webContents as electronWebContents } from 'electron';
 /**
@@ -198,8 +198,8 @@ export function installElementsForward(deps) {
     // bridge per check — NOT a generation snapshot. An event/response is honoured
     // only while its originating guest is still the active one, so switching away
     // and BACK to a previously-wired guest RESUMES its forwarding (a snapshot would
-    // strand it forever — that was bug B2). It also means destroying some OTHER
-    // (non-active) guest never stales the active guest's in-flight commands.
+    // strand it forever). It also means destroying some OTHER (non-active) guest
+    // never stales the active guest's in-flight commands.
     const isActiveWcId = (id) => {
         const a = activeRenderWc();
         return a != null && a.id === id;
@@ -395,7 +395,7 @@ export function installElementsForward(deps) {
             }
             // A destroyed guest is no longer the active one, so its in-flight commands
             // fail `isActiveWcId` and settle as errors on their own — no global bump
-            // (which would wrongly stale OTHER, still-active guests' commands: bug MINOR-3).
+            // (which would wrongly stale OTHER, still-active guests' commands).
             // If we own this wc's session there is nothing left to detach; drop it.
             selfAttached.delete(wc.id);
         };
@@ -430,14 +430,40 @@ export function installElementsForward(deps) {
             catch { /* gone */ }
         });
     }
-    /** enable DOM/CSS/Overlay + wire events on a guest. Best-effort. */
+    /**
+     * enable DOM/CSS/Overlay + wire events on a guest. Best-effort (never throws).
+     *
+     * `Overlay.enable` is sent ONLY AFTER `DOM.enable` has resolved: Chromium rejects
+     * `Overlay.enable` with "DOM should be enabled first" when it arrives before the
+     * DOM domain is enabled, and a silently-dropped rejection leaves Overlay disabled
+     * so every later `Overlay.highlightNode` fails with "Overlay must be enabled" and
+     * the Elements-panel hover highlight never paints. Awaiting DOM.enable first
+     * guarantees the correct enable order. CSS.enable has no such dependency and is
+     * fire-and-forget alongside.
+     */
     function primeGuest(wc) {
         if (!ensureGuestDebugger(wc))
             return;
         wireGuestEvents(wc);
-        for (const domain of ['DOM.enable', 'CSS.enable', 'Overlay.enable']) {
-            wc.debugger.sendCommand(domain).catch(() => { });
+        void enableGuestDomains(wc);
+    }
+    /** Enable the render domains in dependency order. Resolves; never rejects. */
+    async function enableGuestDomains(wc) {
+        wc.debugger.sendCommand('CSS.enable').catch(() => { });
+        try {
+            await wc.debugger.sendCommand('DOM.enable');
         }
+        catch {
+            // Guest mid-destroy or DOM domain unavailable; Overlay.enable would only
+            // re-reject, so stop here rather than firing it out of order.
+            return;
+        }
+        // DOM.enable can settle after the guest was destroyed or the active page
+        // switched away (priming always targets the active guest). Re-check before
+        // arming Overlay so a stale/dead guest is left untouched.
+        if (disposed || !isActiveWcId(wc.id))
+            return;
+        wc.debugger.sendCommand('Overlay.enable').catch(() => { });
     }
     // ── front-end → render command routing ─────────────────────────────────────
     function routeCommand(cmd) {
@@ -465,6 +491,14 @@ export function installElementsForward(deps) {
                 replyError(cmd, 'stale render generation');
                 return;
             }
+            // The front-end emits `Overlay.disable` on Elements-panel state
+            // transitions. Forwarded verbatim it disables the guest's Overlay agent,
+            // after which every `Overlay.highlightNode` fails with "Overlay must be
+            // enabled" and the hover highlight stops painting. Re-arm it so the next
+            // hover paints — only while this guest is still the active one.
+            if (cmd.method === 'Overlay.disable' && isActiveWcId(cmdWcId)) {
+                wc.debugger.sendCommand('Overlay.enable').catch(() => { });
+            }
             replyResult(cmd, result);
         })
             .catch((err) => {

package/dist/main/services/network-forward/index.d.ts

@@ -14,8 +14,8 @@
  * `direct-request.ts`/`simulator-api-network.ts`, which call `fetch()` /
  * `XMLHttpRequest`). Those requests therefore go through the simulator WCV's
  * network stack — a DIFFERENT webContents than the one the DevTools front-end
- * inspects — so they were invisible in the Network panel after the native-host
- * refactor. THAT is the regression this service closes.
+ * inspects — so they are otherwise invisible in the Network panel. This service
+ * surfaces them.
  *
  * ── How it surfaces them (primary sink: native Network tab) ─────────────────
  * We attach the CDP `webContents.debugger` to the simulator WCV, `Network.enable`,
@@ -32,9 +32,8 @@
  * into a namespaced virtual id (`dimina:sim:<epoch>:<rawId>`) before dispatch,
  * keeping a raw→virtual map so redirects / extra-info / completion events on the
  * same request stay correlated. We inject on the MAIN session (no `sessionId`),
- * i.e. the events appear as activity on the currently-inspected target. This is
- * the one-shot approach the Codex review settled on; child-target routing
- * (`Target.attachedToTarget` + hooking outbound CDP) is explicitly deferred.
+ * i.e. the events appear as activity on the currently-inspected target. Child-
+ * target routing (`Target.attachedToTarget` + hooking outbound CDP) is deferred.
  *
  * ── Fallback sink (console line) ────────────────────────────────────────────
  * If the DevTools host wc is unavailable, or `window.DevToolsAPI.dispatchMessage`
@@ -127,7 +126,7 @@ export interface NetworkForwarder extends Disposable {
  * Anything carrying a requestId must be namespaced consistently — even methods
  * we don't (yet) forward — so the raw→virtual map stays coherent if forwarding
  * is widened later. `requestServedFromCache` and `resourceChangedPriority` are
- * included for that reason (MINOR: rewrite-only today, not forwarded).
+ * included for that reason (rewrite-only today, not forwarded).
  */
 export declare const REWRITE_REQUEST_ID_METHODS: ReadonlySet<string>;
 /** The Network.* methods this one-shot pass forwards to the front-end. */

package/dist/main/services/network-forward/index.js

@@ -5,7 +5,7 @@ import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main
  * Anything carrying a requestId must be namespaced consistently — even methods
  * we don't (yet) forward — so the raw→virtual map stays coherent if forwarding
  * is widened later. `requestServedFromCache` and `resourceChangedPriority` are
- * included for that reason (MINOR: rewrite-only today, not forwarded).
+ * included for that reason (rewrite-only today, not forwarded).
  */
 export const REWRITE_REQUEST_ID_METHODS = new Set([
     'Network.requestWillBeSent',
@@ -243,10 +243,9 @@ export function createNetworkForwarder(bridge) {
     let attachDisposables = null;
     // The DevTools front-end host wc (primary sink), set by the ViewManager.
     let devtoolsWc = null;
-    // Teardown for the wc 'destroyed' watcher on the current host (clears the host
-    // here, in this file — view-manager is owned by another change and untouched).
+    // Teardown for the wc 'destroyed' watcher on the current host (clears the host).
     let devtoolsHostDisposable = null;
-    // ── Native-sink state machine (MAJOR 1) ───────────────────────────────────
+    // ── Native-sink state machine ─────────────────────────────────────────────
     let sink = 'idle';
     // Buffered completed-request records while 'probing' — flushed to console if we
     // degrade, dropped if we go ready (so a request shows in exactly one sink).
@@ -321,7 +320,7 @@ export function createNetworkForwarder(bridge) {
     /** Trim the native queue to its cap, preferring to keep request-opening events.
      * Active requests' first events (requestWillBeSent / ...ExtraInfo) are retained
      * so later responseReceived/loadingFinished never become orphans in the panel;
-     * we drop the oldest NON-opening (low-value / completion) events first. (MAJOR 2) */
+     * we drop the oldest NON-opening (low-value / completion) events first. */
     function trimQueue() {
         if (dispatchQueue.length <= MAX_DISPATCH_QUEUE)
             return;
@@ -355,15 +354,15 @@ export function createNetworkForwarder(bridge) {
         }
         const wc = resolveDevtoolsWc();
         if (!wc) {
-            // Host went away mid-flight. Keep the queue bounded (MAJOR 2: cap applies on
+            // Host went away mid-flight. Keep the queue bounded (the cap applies on
             // EVERY path, not just no-host) and wait — setDevtoolsHost re-arms probing.
             trimQueue();
             return;
         }
         if (sink === 'idle')
             beginProbing();
-        // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized
-        // (MAJOR 5); oversized single messages go via the chunked transport.
+        // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized;
+        // oversized single messages go via the chunked transport.
         const batch = [];
         let batchChars = 0;
         let i = 0;
@@ -421,7 +420,7 @@ export function createNetworkForwarder(bridge) {
         }).catch(() => {
             // wc navigated / torn down mid-call, OR the script overflowed IPC. Re-queue
             // (bounded) and let the next flush re-resolve the host. Best-effort; the
-            // ready-timeout still governs giving up. (MAJOR 5: backoff via retry timer.)
+            // ready-timeout still governs giving up. Backoff is via the retry timer.
             if (sink === 'degraded')
                 return;
             dispatchQueue = batch.concat(dispatchQueue);
@@ -654,7 +653,7 @@ export function createNetworkForwarder(bridge) {
     }
     /**
      * Route a completed request to EXACTLY ONE sink, per the native-sink state
-     * machine (MAJOR 1 — no double-display):
+     * machine (no double-display):
      *  - 'ready'    : native path already rendered it → suppress console.
      *  - 'degraded' : native abandoned → console.
      *  - 'idle'     : no host configured → console (the native queue never flushes).

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -39,10 +39,9 @@ export interface WorkbenchSettingsInitPayload {
 }
 /**
  * Unified entry point for every main → renderer event sent by the devtools
- * main process. Every site that previously called
- * `someWebContents.send(channel, payload)` now goes through a typed method
- * here so that channel names, payload shapes and `isDestroyed()` guards live
- * in exactly one place.
+ * main process. Instead of calling `someWebContents.send(channel, payload)`
+ * directly, every site goes through a typed method here so that channel names,
+ * payload shapes and `isDestroyed()` guards live in exactly one place.
  *
  * Methods resolve their target `WebContents` lazily from references provided
  * at call time (or read from the owning context) and silently no-op when the

package/dist/main/services/projects/index.js

@@ -3,7 +3,7 @@
 // higher-level coordination (session + renderer notifications) lives in
 // ../workspace/workspace-service.ts.
 //
-// Phase 1 adds the extensibility surface: `types.ts` (ProjectsProvider,
+// The extensibility surface lives in `types.ts` (ProjectsProvider,
 // ProjectTemplate, CreateProjectInput) and `local-provider.ts` (the default
 // implementation injected when the host omits `projectsProvider`).
 export * from './project-repository.js';

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

@@ -2,11 +2,47 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { devtoolsPackageRoot } from '../../utils/paths.js';
 const DEFAULT_SOURCE_PATH = 'dist/render-host/render-inspect.js';
+/**
+ * Chrome DevTools' default Elements-panel highlight palette (content / padding /
+ * border / margin tints + the size tooltip). Mirroring it makes the WXML panel's
+ * hover box visually identical to the embedded Elements panel's.
+ */
+const HIGHLIGHT_CONFIG = {
+    showInfo: true,
+    showRulers: false,
+    showExtensionLines: false,
+    contentColor: { r: 111, g: 168, b: 220, a: 0.66 },
+    paddingColor: { r: 147, g: 196, b: 125, a: 0.55 },
+    borderColor: { r: 255, g: 229, b: 153, a: 0.66 },
+    marginColor: { r: 246, g: 178, b: 107, a: 0.66 },
+};
+/** Object group for the per-hover `Runtime.evaluate` reference, released after the draw. */
+const HOVER_OBJECT_GROUP = 'render-inspect-hover';
+/**
+ * Upper bound on awaiting the `DOM.enable → Overlay.enable` handshake before
+ * highlighting. A hung `DOM.enable` then degrades to a missed paint instead of a
+ * stuck hover.
+ */
+const ENABLE_HANDSHAKE_TIMEOUT_MS = 500;
+/** Resolve when `p` settles or `ms` elapses, whichever comes first (never rejects). */
+function withTimeout(p, ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        p.then(() => { clearTimeout(timer); resolve(); }, () => { clearTimeout(timer); resolve(); });
+    });
+}
 export function createRenderInspector(options = {}) {
     const loadSource = options.loadSource ??
         (() => readFileSync(path.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), 'utf8'));
     let cachedSource = null;
     const injected = new Set();
+    // Debugger sessions THIS service attached itself (nobody else owned one). Only
+    // these are detached on guest-destroy; sessions safe-area / Elements-forward
+    // own are never touched (single-owner per wc).
+    const selfAttached = new Set();
+    // Per-wc `DOM.enable → Overlay.enable` handshake, started once and reused so a
+    // burst of hovers shares one enable. Cleared when the guest is destroyed.
+    const enablePromises = new Map();
     function source() {
         if (cachedSource === null)
             cachedSource = loadSource();
@@ -37,11 +73,15 @@ export function createRenderInspector(options = {}) {
         // Consolidate the per-wc bookkeeping teardown onto the connection layer
         // (foundation.md §4 / P2) when a registry is available; fall back to the
         // bespoke `once('destroyed')` only when omitted (focused unit tests).
+        const forget = () => {
+            injected.delete(wc.id);
+            enablePromises.delete(wc.id);
+        };
         if (options.connections) {
-            options.connections.acquire(wc).own(() => injected.delete(wc.id));
+            options.connections.acquire(wc).own(forget);
         }
         else {
-            wc.once('destroyed', () => injected.delete(wc.id));
+            wc.once('destroyed', forget);
         }
         return true;
     }
@@ -63,21 +103,157 @@ export function createRenderInspector(options = {}) {
             return null;
         if (!(await ensureInjected(wc)))
             return null;
+        let inspection;
         try {
             const result = await wc.executeJavaScript(`window.__diminaRenderInspect ? window.__diminaRenderInspect.highlightElement(${JSON.stringify(sid)}) : null`);
-            return result ?? null;
+            inspection = result ?? null;
         }
         catch {
             return null;
         }
+        // No geometry → nothing to draw; never touch the debugger.
+        if (!inspection)
+            return null;
+        // Draw the native overlay best-effort: the inspection data must survive even
+        // if the CDP draw fails, so a rejected debugger step never propagates.
+        await drawNativeHighlight(wc, sid).catch(() => { });
+        return inspection;
     }
-    async function unhighlight(wc) {
+    /**
+     * Paint the Chrome-style native highlight over the guest via CDP — the same
+     * `Overlay.highlightNode` the embedded Elements panel uses, so the WXML panel's
+     * hover box matches it exactly. Reuses the guest's existing debugger session
+     * (single-owner per wc; safe-area / Elements-forward has usually already
+     * attached it) and only attaches itself when nobody has.
+     *
+     * `Overlay.highlightNode` paints only while the Overlay domain is enabled, and
+     * Chromium rejects `Overlay.enable` with "DOM should be enabled first" unless
+     * DOM is enabled first. On a cold/self-attached session (WXML hovered without
+     * the Elements panel ever enabling Overlay) the highlight would silently no-op
+     * if the command raced ahead of the enable, so we AWAIT the `DOM.enable →
+     * Overlay.enable` handshake before highlighting — but only up to
+     * `ENABLE_HANDSHAKE_TIMEOUT_MS`, so a hung `DOM.enable` degrades to a missed
+     * paint rather than a stuck hover.
+     *
+     * The `Runtime.evaluate` runs in a named object group whose remote references
+     * are released in `finally`; otherwise every hover would leak a live DOM
+     * wrapper into the guest's execution context.
+     */
+    async function drawNativeHighlight(wc, sid) {
         if (wc.isDestroyed())
             return;
-        if (!(await ensureInjected(wc)))
+        if (!ensureGuestDebugger(wc))
+            return;
+        await withTimeout(ensureDomainsEnabled(wc), ENABLE_HANDSHAKE_TIMEOUT_MS);
+        if (wc.isDestroyed())
+            return;
+        const expression = `window.__diminaRenderInspect && window.__diminaRenderInspect.elementFor(${JSON.stringify(sid)})`;
+        try {
+            const evaluated = await wc.debugger.sendCommand('Runtime.evaluate', {
+                expression,
+                returnByValue: false,
+                objectGroup: HOVER_OBJECT_GROUP,
+            });
+            const objectId = evaluated?.result?.objectId;
+            if (!objectId)
+                return;
+            await wc.debugger.sendCommand('Overlay.highlightNode', {
+                objectId,
+                highlightConfig: HIGHLIGHT_CONFIG,
+            });
+        }
+        finally {
+            // Drop the hover's remote DOM reference so repeated hovers don't accumulate
+            // live wrappers in the guest context.
+            wc.debugger
+                .sendCommand('Runtime.releaseObjectGroup', { objectGroup: HOVER_OBJECT_GROUP })
+                .catch(() => { });
+        }
+    }
+    /**
+     * Ensure the guest's debugger is usable WITHOUT opening a second session: a
+     * webContents debugger is single-owner, so reuse the already-attached session
+     * (Elements-forward / safe-area) and only `attach('1.3')` when nobody has. The
+     * sessions we open ourselves are tracked so guest-destroy detaches only ours.
+     * Returns false when the debugger can't be made usable.
+     */
+    function ensureGuestDebugger(wc) {
+        try {
+            if (wc.debugger.isAttached())
+                return true;
+        }
+        catch {
+            return false;
+        }
+        try {
+            wc.debugger.attach('1.3');
+            trackSelfAttached(wc);
+            return true;
+        }
+        catch {
+            // A concurrent attach (race) leaves it usable; anything else is a failure.
+            try {
+                return wc.debugger.isAttached();
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    /** Record a self-attached session and detach it when the guest is destroyed. */
+    function trackSelfAttached(wc) {
+        if (selfAttached.has(wc.id))
+            return;
+        selfAttached.add(wc.id);
+        const detach = () => {
+            selfAttached.delete(wc.id);
+            try {
+                if (!wc.isDestroyed() && wc.debugger.isAttached())
+                    wc.debugger.detach();
+            }
+            catch { /* already gone */ }
+        };
+        if (options.connections)
+            options.connections.acquire(wc).own(detach);
+        else {
+            try {
+                wc.once('destroyed', () => selfAttached.delete(wc.id));
+            }
+            catch { /* fake wc */ }
+        }
+    }
+    /**
+     * Enable the DOM + Overlay render domains in dependency order, ONCE per guest
+     * (the promise is cached + reused across hovers). `Overlay.enable` is sent ONLY
+     * AFTER `DOM.enable` resolves (Chromium rejects it otherwise). Resolves when
+     * Overlay is enabled; a rejection at any step is swallowed (the guest may be
+     * mid-teardown) and the cache entry is dropped so a later hover can retry.
+     */
+    function ensureDomainsEnabled(wc) {
+        const cached = enablePromises.get(wc.id);
+        if (cached)
+            return cached;
+        wc.debugger.sendCommand('CSS.enable').catch(() => { });
+        const handshake = wc.debugger
+            .sendCommand('DOM.enable')
+            .then(() => {
+            if (wc.isDestroyed())
+                return;
+            return wc.debugger.sendCommand('Overlay.enable');
+        })
+            .then(() => undefined)
+            .catch(() => {
+            // Allow a retry on the next hover (e.g. the guest was mid-destroy).
+            enablePromises.delete(wc.id);
+        });
+        enablePromises.set(wc.id, handshake);
+        return handshake;
+    }
+    async function unhighlight(wc) {
+        if (wc.isDestroyed())
             return;
         try {
-            await wc.executeJavaScript('window.__diminaRenderInspect && window.__diminaRenderInspect.unhighlightElement && window.__diminaRenderInspect.unhighlightElement()');
+            await wc.debugger.sendCommand('Overlay.hideHighlight');
         }
         catch {
             // best-effort

package/dist/main/services/service-console/console-api.d.ts

@@ -1,12 +1,11 @@
 /**
  * Pure helpers for the native-host service-console forwarder.
  *
- * Under native-host the service-host's console used to be captured by a
- * `console.*` monkeypatch in `service-host/preload.cjs`. That wrapper added a
- * stack frame, so Chrome DevTools (attached natively to the service host)
- * attributed EVERY service-layer log to the wrapper line (`preload.cjs:237`)
- * instead of the developer's source. We now capture via CDP
- * `Runtime.consoleAPICalled` instead, which preserves native source attribution.
+ * The service-host's console is captured via CDP `Runtime.consoleAPICalled`,
+ * which preserves native source attribution. A `console.*` monkeypatch in
+ * `service-host/preload.cjs` would add a stack frame, so Chrome DevTools (attached
+ * natively to the service host) would attribute EVERY service-layer log to the
+ * wrapper line instead of the developer's source.
  *
  * These functions turn the CDP event shape into the `GuestConsoleEntry` shape
  * the existing console fan-out (automation `App.logAdded`) expects, WITHOUT any

package/dist/main/services/service-console/console-api.js

@@ -1,12 +1,11 @@
 /**
  * Pure helpers for the native-host service-console forwarder.
  *
- * Under native-host the service-host's console used to be captured by a
- * `console.*` monkeypatch in `service-host/preload.cjs`. That wrapper added a
- * stack frame, so Chrome DevTools (attached natively to the service host)
- * attributed EVERY service-layer log to the wrapper line (`preload.cjs:237`)
- * instead of the developer's source. We now capture via CDP
- * `Runtime.consoleAPICalled` instead, which preserves native source attribution.
+ * The service-host's console is captured via CDP `Runtime.consoleAPICalled`,
+ * which preserves native source attribution. A `console.*` monkeypatch in
+ * `service-host/preload.cjs` would add a stack frame, so Chrome DevTools (attached
+ * natively to the service host) would attribute EVERY service-layer log to the
+ * wrapper line instead of the developer's source.
  *
  * These functions turn the CDP event shape into the `GuestConsoleEntry` shape
  * the existing console fan-out (automation `App.logAdded`) expects, WITHOUT any

package/dist/main/services/service-host-pool/pool.d.ts

@@ -7,9 +7,8 @@ import { BrowserWindow } from 'electron';
  * (release / releaseDestroyed), opt-in behind `DIMINA_PREWARM_POOL_SIZE`
  * (default OFF). Only the SERVICE-HOST window is pooled; the simulator content
  * WebContentsView (`view-manager.attachNativeSimulator`) is created fresh per
- * attach. (The historical `<webview>`-tag default arch was never poolable —
- * Electron can't reparent a pre-warmed WebContents into a `<webview>`; doc §5
- * Phase 4 — and that route has since been deleted outright.)
+ * attach. (A `<webview>`-tag arch is not poolable — Electron can't reparent a
+ * pre-warmed WebContents into a `<webview>`.)
  *
  * Lifecycle of a pool entry:
  *   warming   — BrowserWindow constructed, page loading

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

@@ -2,11 +2,9 @@
  * SimulatorStorageWatcher
  *
  * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
- * and forwards `DOMStorage.*` events to the renderer host. Replaces the
- * preload-side localStorage.setItem hook that used to push storage changes
- * via SimulatorChannel.Storage / StorageAll.
+ * and forwards `DOMStorage.*` events to the renderer host.
  *
- * Trade-offs vs the preload approach:
+ * Trade-offs vs a preload-side localStorage.setItem hook:
  *   + Uses standard browser protocol; no preload injection
  *   + Captures every change including ones bypassing wx (api-compat fallback,
  *     direct localStorage.setItem from devtools, etc.)

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

@@ -2,11 +2,9 @@
  * SimulatorStorageWatcher
  *
  * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
- * and forwards `DOMStorage.*` events to the renderer host. Replaces the
- * preload-side localStorage.setItem hook that used to push storage changes
- * via SimulatorChannel.Storage / StorageAll.
+ * and forwards `DOMStorage.*` events to the renderer host.
  *
- * Trade-offs vs the preload approach:
+ * Trade-offs vs a preload-side localStorage.setItem hook:
  *   + Uses standard browser protocol; no preload injection
  *   + Captures every change including ones bypassing wx (api-compat fallback,
  *     direct localStorage.setItem from devtools, etc.)

package/dist/main/services/simulator-temp-files/index.js

@@ -155,8 +155,8 @@ export function setupSimulatorTempFiles(simSession) {
     installOnSession(simSession);
     // Apply to every per-project miniapp partition session (current + future).
     const unregisterConfigurator = registerMiniappSessionConfigurator((sess) => installOnSession(sess));
-    // Phase 1 (P1-7): renderer FSM → main fs operations bridge. The same
-    // simulator-only sender policy applies — registry instance is shared.
+    // Renderer FSM → main fs operations bridge. The same simulator-only sender
+    // policy applies — registry instance is shared.
     registry.handle('simulator:fs:read', (_event, payload) => handleFsRead(payload));
     registry.handle('simulator:fs:write', (_event, payload) => handleFsWrite(payload));
     registry.handle('simulator:fs:stat', (_event, payload) => handleFsStat(payload));

package/dist/main/services/views/devtools-tabs.d.ts

@@ -35,7 +35,10 @@
  */
 /**
  * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
- * ids, unchanged for many Chromium releases): `elements`, `console`, `network`.
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `network`,
+ * `sources`. Sources stays so a source-link click that isn't routed to Monaco
+ * (build/runtime chunks, framework frames) still has a panel to reveal in instead
+ * of silently no-op'ing.
  */
 export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
 /**