@dimina-kit/devtools 0.3.2-dev.20260525152421 → 0.3.2-dev.20260610082053

package/dist/main/services/automation/handlers/page.js

@@ -1,16 +1,35 @@
-import { evalInSim, inIframe } from '../exec.js';
+import { evalInActivePage, evalInSim } from '../exec.js';
 import { registerElement } from '../registry.js';
 export const pageHandlers = {};
+/**
+ * Resolve a dotted/indexed path (`a.b`, `a[0].b`) against an appdata object,
+ * or return the whole object when no path is given. Shared by both Page.getData
+ * branches so the traversal stays identical.
+ */
+function resolveAppDataPath(appdata, pathKey) {
+    if (!pathKey)
+        return appdata;
+    const keys = pathKey.replace(/\[(\d+)\]/g, '.$1').split('.');
+    let val = appdata;
+    for (const k of keys) {
+        if (val == null || typeof val !== 'object') {
+            val = undefined;
+            break;
+        }
+        val = val[k];
+    }
+    return val;
+}
 // -- Page domain --
 pageHandlers['Page.getElement'] = async (ctx, params) => {
     const selector = params.selector;
     const pageId = params.pageId || 1;
     const escaped = selector.replace(/'/g, "\\'");
-    const info = await evalInSim(ctx, inIframe(`
+    const info = await evalInActivePage(ctx, `
     const el = _doc.querySelector('${escaped}')
     if (!el) return null
     return { tagName: el.tagName.toLowerCase() }
-  `));
+  `);
     if (!info)
         throw new Error(`Element not found: ${selector}`);
     const elementId = registerElement(selector, 0, pageId);
@@ -20,11 +39,11 @@ pageHandlers['Page.getElements'] = async (ctx, params) => {
     const selector = params.selector;
     const pageId = params.pageId || 1;
     const escaped = selector.replace(/'/g, "\\'");
-    const items = await evalInSim(ctx, inIframe(`
+    const items = await evalInActivePage(ctx, `
     return Array.from(_doc.querySelectorAll('${escaped}')).map(el => ({
       tagName: el.tagName.toLowerCase(),
     }))
-  `));
+  `);
     return {
         elements: items.map((item, i) => ({
             elementId: registerElement(selector, i, pageId),
@@ -34,19 +53,17 @@ pageHandlers['Page.getElements'] = async (ctx, params) => {
 };
 pageHandlers['Page.getData'] = async (ctx, params) => {
     const pathKey = params.path;
-    const appdata = await evalInSim(ctx, `window.__simulatorData ? window.__simulatorData.getAppdata() : {}`);
-    if (!pathKey)
-        return { data: appdata };
-    const keys = pathKey.replace(/\[(\d+)\]/g, '.$1').split('.');
-    let val = appdata;
-    for (const k of keys) {
-        if (val == null || typeof val !== 'object') {
-            val = undefined;
-            break;
-        }
-        val = val[k];
+    // NATIVE-HOST: under native-host the page AppData lives in the service window's
+    // Worker-less runtime (tracked centrally via ctx.appData), NOT in the render
+    // guest's DOM. Source the active bridge's reactive state from the central
+    // accumulator, then run the SAME path traversal as the default branch.
+    if (ctx.bridge?.isNativeHost()) {
+        const bridgeId = ctx.bridge.getActiveBridgeId();
+        const appdata = bridgeId ? (ctx.appData?.getPageData(bridgeId) ?? {}) : {};
+        return { data: resolveAppDataPath(appdata, pathKey) };
     }
-    return { data: val };
+    const appdata = await evalInSim(ctx, `window.__simulatorData ? window.__simulatorData.getAppdata() : {}`);
+    return { data: resolveAppDataPath(appdata, pathKey) };
 };
 pageHandlers['Page.setData'] = async () => {
     throw new Error('Page.setData is not supported (requires AppService layer)');
@@ -56,11 +73,11 @@ pageHandlers['Page.callMethod'] = async (_ctx, params) => {
 };
 pageHandlers['Page.getWindowProperties'] = async (ctx, params) => {
     const names = params.names;
-    const properties = await evalInSim(ctx, inIframe(`
+    const properties = await evalInActivePage(ctx, `
     return ${JSON.stringify(names)}.map(n => {
       try { return eval(n) } catch { return undefined }
     })
-  `));
+  `);
     return { properties };
 };
 //# sourceMappingURL=page.js.map

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

@@ -54,6 +54,23 @@ export async function startAutomationServer(ctx, port = 0) {
                 ws.send(msg);
         }
     }
+    // Native-host console forwarding: under native-host the page/service console
+    // doesn't flow through the simulator guest's `ipc-message-host` channel (there
+    // is no Worker/MiniApp in the guest). Instead the render-host / service-host
+    // preloads post each console entry to main, bridge-router routes it to the
+    // always-on ConsoleForwarder, and we SUBSCRIBE to rebroadcast every entry
+    // (both layers) as an `App.logAdded` event — same shape the default-arch path
+    // emits below in `setupConsoleForwarding`. We no longer set `ctx.guestConsole`
+    // ourselves (the forwarder owns it); subscribing means render + service both
+    // reach automation while the forwarder also mirrors render into the service
+    // host's console for the embedded DevTools. Unsubscribed on close().
+    const consoleSub = ctx.consoleForwarder?.subscribe((entry) => {
+        const e = (entry ?? {});
+        broadcast({
+            method: 'App.logAdded',
+            params: { type: e.level || 'log', args: e.args || [] },
+        });
+    });
     // Forward simulator console logs as App.logAdded events.
     // Track the polling interval + stop timer + currently-attached sim and
     // the named handler so we can fully detach on close() or sim destruction.
@@ -64,7 +81,11 @@ export async function startAutomationServer(ctx, port = 0) {
     let pollStopTimer = null;
     let attachedSim = null;
     let ipcMessageHostHandler = null;
-    let simDestroyedHandler = null;
+    // Handle for the destroyed-teardown owned by the sim's connection (replaces a
+    // bespoke `sim.once('destroyed')` + manual removeListener). Disposing it on
+    // graceful close()/detach releases the disposer from the connection segment so
+    // it can't accumulate across automation create/dispose cycles on the same sim.
+    let simDestroyedDisposer = null;
     function detachConsoleForwarding() {
         if (attachedSim) {
             if (ipcMessageHostHandler) {
@@ -77,18 +98,16 @@ export async function startAutomationServer(ctx, port = 0) {
                 }
                 catch { /* noop */ }
             }
-            if (simDestroyedHandler) {
-                try {
-                    if (!attachedSim.isDestroyed()) {
-                        attachedSim.removeListener('destroyed', simDestroyedHandler);
-                    }
-                }
-                catch { /* noop */ }
-            }
         }
+        // Release the connection-owned destroyed disposer (idempotent; safe even if
+        // the sim is already destroyed — the disposer body only nulls local refs).
+        try {
+            simDestroyedDisposer?.dispose();
+        }
+        catch { /* noop */ }
         attachedSim = null;
         ipcMessageHostHandler = null;
-        simDestroyedHandler = null;
+        simDestroyedDisposer = null;
     }
     function setupConsoleForwarding() {
         if (consoleForwardingSetup)
@@ -116,14 +135,17 @@ export async function startAutomationServer(ctx, port = 0) {
                 // sender would throw) and allow re-attach to a new simulator.
                 attachedSim = null;
                 ipcMessageHostHandler = null;
-                simDestroyedHandler = null;
+                simDestroyedDisposer = null;
                 consoleForwardingSetup = false;
             };
             attachedSim = sim;
             ipcMessageHostHandler = onIpcMessageHost;
-            simDestroyedHandler = onSimDestroyed;
             sim.on('ipc-message-host', onIpcMessageHost);
-            sim.once('destroyed', onSimDestroyed);
+            // Route the destroyed-teardown through the per-webContents connection
+            // registry: the connection arms a single `wc.once('destroyed')` and runs
+            // owned disposers on hard-destroy (or soft reset for pool reuse), so we no
+            // longer manage a bespoke 'destroyed' listener here.
+            simDestroyedDisposer = ctx.connections.acquire(sim).own(onSimDestroyed);
         }, 1000);
         // Stop polling after 30s
         pollStopTimer = setTimeout(() => {
@@ -176,6 +198,11 @@ export async function startAutomationServer(ctx, port = 0) {
                 pollStopTimer = null;
             }
             detachConsoleForwarding();
+            // Unsubscribe from the always-on ConsoleForwarder so a late guest console
+            // entry can't broadcast against a torn-down server. The forwarder keeps
+            // owning `ctx.guestConsole` (render→service mirroring continues without an
+            // automation client). No-op if the forwarder was absent.
+            consoleSub?.dispose();
             for (const ws of clients) {
                 try {
                     ws.close();

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

@@ -0,0 +1,56 @@
+/**
+ * Cross-process readiness primitive (shared abstraction).
+ *
+ * Replaces the blind `setTimeout(1500/2000)` navigation waits in automation
+ * handlers with "wait for the bridge's `activePage` signal, with a timeout
+ * floor". The bridge (`BridgeRouterHandle`) already fan-outs an `activePage`
+ * render event whenever the DeviceShell reports a new top-of-stack page, so we
+ * wait for that real signal instead of guessing how long a navigation takes.
+ *
+ * Design contract:
+ *   - Subscribe to `bridge.onRenderEvent` and resolve on the first matching
+ *     `activePage` event. "Matching" = `opts.match(bridgeId, pagePath)` when a
+ *     predicate is supplied, otherwise `bridgeId !== opts.since` (i.e. the
+ *     active page actually changed away from where navigation started).
+ *   - Timeout floor: resolve (NEVER reject, never hang) at `opts.timeoutMs` so a
+ *     caller awaiting this can always make progress even if the signal is lost.
+ *   - Race close: navigation can land before we subscribe, so read
+ *     `getActiveBridgeId()` once right after subscribing; when no `match`
+ *     predicate is given and it is already `!== since`, resolve immediately.
+ *     (With a `match` predicate we cannot decide from the bridgeId alone — there
+ *     is no pagePath in the snapshot — so we wait for an event.)
+ *   - Resolve exactly once; later events are inert and the subscription is torn
+ *     down on resolve.
+ */
+/** The render-event shape `waitForActivePage` reads (subset of `RenderEvent`). */
+export interface ActivePageEventLike {
+    kind: 'domReady' | 'activePage';
+    appId: string;
+    bridgeId: string;
+    pagePath?: string;
+}
+/** Minimal bridge surface this helper is allowed to touch. */
+export interface WaitActivePageBridge {
+    onRenderEvent(listener: (event: ActivePageEventLike) => void): () => void;
+    getActiveBridgeId(): string | null;
+}
+export interface WaitActivePageOptions {
+    /** The active bridgeId before navigation started (or null if unknown). */
+    since: string | null;
+    /** Timeout floor in ms — resolve unconditionally once this elapses. */
+    timeoutMs: number;
+    /**
+     * Optional predicate deciding which `activePage` event ends the wait. When
+     * omitted, any `activePage` whose `bridgeId !== since` ends it.
+     */
+    match?: (bridgeId: string, pagePath?: string) => boolean;
+    /**
+     * Fired exactly once if the wait resolves via the timeout floor rather than a
+     * matching signal — i.e. the expected `activePage` was never observed. Lets
+     * the caller surface "signal not seen, proceeding on timeout" instead of
+     * silently masking a lost signal. Never fired on a signal/race-close resolve.
+     */
+    onTimeout?: () => void;
+}
+export declare function waitForActivePage(bridge: WaitActivePageBridge, opts: WaitActivePageOptions): Promise<void>;
+//# sourceMappingURL=wait-active-page.d.ts.map

package/dist/main/services/automation/wait-active-page.js

@@ -0,0 +1,71 @@
+/**
+ * Cross-process readiness primitive (shared abstraction).
+ *
+ * Replaces the blind `setTimeout(1500/2000)` navigation waits in automation
+ * handlers with "wait for the bridge's `activePage` signal, with a timeout
+ * floor". The bridge (`BridgeRouterHandle`) already fan-outs an `activePage`
+ * render event whenever the DeviceShell reports a new top-of-stack page, so we
+ * wait for that real signal instead of guessing how long a navigation takes.
+ *
+ * Design contract:
+ *   - Subscribe to `bridge.onRenderEvent` and resolve on the first matching
+ *     `activePage` event. "Matching" = `opts.match(bridgeId, pagePath)` when a
+ *     predicate is supplied, otherwise `bridgeId !== opts.since` (i.e. the
+ *     active page actually changed away from where navigation started).
+ *   - Timeout floor: resolve (NEVER reject, never hang) at `opts.timeoutMs` so a
+ *     caller awaiting this can always make progress even if the signal is lost.
+ *   - Race close: navigation can land before we subscribe, so read
+ *     `getActiveBridgeId()` once right after subscribing; when no `match`
+ *     predicate is given and it is already `!== since`, resolve immediately.
+ *     (With a `match` predicate we cannot decide from the bridgeId alone — there
+ *     is no pagePath in the snapshot — so we wait for an event.)
+ *   - Resolve exactly once; later events are inert and the subscription is torn
+ *     down on resolve.
+ */
+export function waitForActivePage(bridge, opts) {
+    const { since, timeoutMs, match, onTimeout } = opts;
+    return new Promise((resolve) => {
+        let isSettled = false;
+        let unsubscribe = null;
+        let timer = null;
+        const finish = () => {
+            if (isSettled)
+                return;
+            isSettled = true;
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (unsubscribe) {
+                unsubscribe();
+                unsubscribe = null;
+            }
+            resolve();
+        };
+        const matches = (bridgeId, pagePath) => match ? match(bridgeId, pagePath) : bridgeId !== since;
+        unsubscribe = bridge.onRenderEvent((event) => {
+            if (isSettled)
+                return;
+            if (event.kind !== 'activePage')
+                return;
+            if (matches(event.bridgeId, event.pagePath))
+                finish();
+        });
+        // Timeout floor — resolve (never reject) so awaiters never hang. Fire the
+        // optional onTimeout hook first so a lost signal is visible, not masked.
+        timer = setTimeout(() => {
+            if (isSettled)
+                return;
+            onTimeout?.();
+            finish();
+        }, timeoutMs);
+        // Race close: the page may already have advanced before we subscribed.
+        // Only decidable without a pagePath when no `match` predicate is supplied.
+        if (!match) {
+            const current = bridge.getActiveBridgeId();
+            if (current !== null && current !== since)
+                finish();
+        }
+    });
+}
+//# sourceMappingURL=wait-active-page.js.map

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

@@ -0,0 +1,36 @@
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+/**
+ * One console entry posted by a guest preload. Shape mirrors
+ * render-host/preload.cjs + service-host/preload.cjs `emitConsoleLog`:
+ *   - `source`  which layer it came from ('render' | 'service'); ONLY 'render'
+ *               is forwarded into the service host (see loop-safety above).
+ *   - `bridgeId` present for render entries; identifies the owning page so we
+ *               can target the matching app's service host (multi-app safe).
+ *   - `level`   console method name ('log' | 'warn' | 'error' | 'info' | 'debug').
+ *   - `args`    already-`safeSerialize`d arguments (structured-cloneable).
+ */
+export interface GuestConsoleEntry {
+    source?: string;
+    bridgeId?: string;
+    level?: string;
+    args?: unknown[];
+    ts?: number;
+}
+/** A consumer of every guest console entry (render AND service). */
+export type ConsoleSink = (entry: GuestConsoleEntry) => void;
+export interface ConsoleForwarder extends Disposable {
+    /**
+     * The single sink bridge-router invokes (wired onto `ctx.guestConsole.emit`).
+     * Fans every entry out to subscribers, then runs the render→service forward.
+     */
+    emit(entry: unknown): void;
+    /**
+     * Register an external sink (e.g. automation WS broadcast). Returns a
+     * Disposable that unregisters it. Sinks see EVERY entry (both layers) — the
+     * render→service forward is internal and not exposed as a sink.
+     */
+    subscribe(sink: ConsoleSink): Disposable;
+}
+export declare function createConsoleForwarder(bridge: Pick<BridgeRouterHandle, 'getServiceWc' | 'getServiceWcForBridge'>): ConsoleForwarder;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,81 @@
+import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
+/** Console levels we re-emit into the service host. Anything else maps to 'log'. */
+const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
+/**
+ * Build the `executeJavaScript` source that re-emits a render entry inside the
+ * service host. Args are carried as a JSON string and parsed service-side, so no
+ * guest-controlled value is ever interpolated into executable JS — the only
+ * thing that reaches the parser is a JSON literal. The `[视图]` prefix lets the
+ * DevTools console filter isolate the render layer.
+ */
+function buildForwardScript(level, args) {
+    const method = FORWARDABLE_LEVELS.has(level) ? level : 'log';
+    // JSON.stringify('…') yields a valid JS string literal; embedding it and
+    // re-parsing keeps args as data, never code. JSON.stringify can throw on a
+    // value that slipped past safeSerialize (e.g. a BigInt) — caller guards.
+    const argsJson = JSON.stringify(args ?? []);
+    // `console[method]` (not `console.log`) preserves the original level so the
+    // DevTools severity filter still works on the forwarded line.
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[视图]',...a)}catch(_){}})()`;
+}
+export function createConsoleForwarder(bridge) {
+    const sinks = new Set();
+    const registry = new DisposableRegistry();
+    /**
+     * Render→service forward. Resolves the service host for the entry's owning
+     * page (multi-app safe), falling back to the active app's service host when
+     * the bridgeId is unknown — that's the host the embedded DevTools inspects.
+     * No-op on a destroyed/missing host so we never write to a torn-down wc (pool
+     * reuse / session swap can swap the host out under us).
+     */
+    function forwardRenderToServiceHost(entry) {
+        let wc = null;
+        if (entry.bridgeId && bridge.getServiceWcForBridge) {
+            wc = bridge.getServiceWcForBridge(entry.bridgeId);
+        }
+        if (!wc)
+            wc = bridge.getServiceWc();
+        if (!wc || wc.isDestroyed())
+            return;
+        let script;
+        try {
+            script = buildForwardScript(entry.level ?? 'log', entry.args ?? []);
+        }
+        catch {
+            // Args that escaped safeSerialize and aren't JSON-stringifiable — drop
+            // rather than break the forward. Console capture must never throw.
+            return;
+        }
+        // executeJavaScript rejects if the host navigates/teardowns mid-call; the
+        // injected body is itself try/caught. Swallow either — best-effort mirror.
+        wc.executeJavaScript(script, true).catch(() => { });
+    }
+    return {
+        // The single sink bridge-router calls (`ctx.guestConsole.emit`). Fans out
+        // to external subscribers (both layers) then runs the render→service forward
+        // (render only — see loop-safety invariant in the module header).
+        emit(raw) {
+            const entry = (raw ?? {});
+            for (const sink of sinks) {
+                try {
+                    sink(entry);
+                }
+                catch { /* a sink must never break the others */ }
+            }
+            // Forward ONLY the render layer. Service entries are already shown
+            // natively in the attached DevTools, and forwarding them would loop
+            // (see header).
+            if (entry.source === 'render')
+                forwardRenderToServiceHost(entry);
+        },
+        subscribe(sink) {
+            sinks.add(sink);
+            return registry.add(toDisposable(() => { sinks.delete(sink); }));
+        },
+        dispose() {
+            sinks.clear();
+            return registry.disposeAll();
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/main/services/dimina-resource-server.d.ts

@@ -0,0 +1,7 @@
+export interface DiminaResourceServer {
+    baseUrl: string;
+    close(): Promise<void>;
+}
+export declare function startDiminaResourceServer(rootDir: string): Promise<DiminaResourceServer>;
+export declare function toSourceUrl(filePath: string): string;
+//# sourceMappingURL=dimina-resource-server.d.ts.map

package/dist/main/services/dimina-resource-server.js

@@ -0,0 +1,99 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const MIME_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.wasm': 'application/wasm',
+};
+export async function startDiminaResourceServer(rootDir) {
+    const root = path.resolve(rootDir);
+    const server = http.createServer((req, res) => {
+        void handleRequest(root, req, res);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}/`,
+        close() {
+            return new Promise((resolve, reject) => {
+                server.close((err) => err ? reject(err) : resolve());
+            });
+        },
+    };
+}
+async function handleRequest(root, req, res) {
+    setCorsHeaders(res);
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.writeHead(405);
+        res.end('Method Not Allowed');
+        return;
+    }
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+    const filePath = resolveContainedPath(root, decodeURIComponent(url.pathname));
+    if (!filePath) {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
+    try {
+        const stat = await fs.promises.stat(filePath);
+        if (!stat.isFile()) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        res.writeHead(200, {
+            'content-type': MIME_TYPES[path.extname(filePath)] ?? 'application/octet-stream',
+            'content-length': stat.size,
+            'cache-control': 'no-store',
+        });
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        fs.createReadStream(filePath).pipe(res);
+    }
+    catch {
+        res.writeHead(404);
+        res.end('Not Found');
+    }
+}
+function resolveContainedPath(root, pathname) {
+    const relative = pathname.replace(/^\/+/, '') || 'index.html';
+    const resolved = path.resolve(root, relative);
+    if (resolved !== root && !resolved.startsWith(root + path.sep))
+        return null;
+    return resolved;
+}
+function setCorsHeaders(res) {
+    res.setHeader('access-control-allow-origin', '*');
+    res.setHeader('access-control-allow-headers', '*');
+    res.setHeader('access-control-allow-methods', 'GET,HEAD,OPTIONS');
+    res.setHeader('cross-origin-resource-policy', 'cross-origin');
+}
+export function toSourceUrl(filePath) {
+    return pathToFileURL(filePath).toString();
+}
+//# sourceMappingURL=dimina-resource-server.js.map

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

@@ -0,0 +1,66 @@
+import type { WebContents } from 'electron';
+import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
+import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+/** Which target a front-end CDP command is routed to. */
+export type CdpRoute = 'render' | 'service';
+/**
+ * Decide where a front-end CDP `method` is routed.
+ *
+ *  render  → DOM./CSS./Overlay./DOMSnapshot./DOMDebugger.  (the Elements tree)
+ *  service → EVERYTHING ELSE, and in particular:
+ *    • Emulation.*  — RED LINE: routing this to the render guest would let the
+ *      front-end overwrite the safe-area service's `setSafeAreaInsetsOverride`.
+ *      It MUST stay on the service-host inspection path (pass-through).
+ *    • Runtime./Console./Debugger./Network./Page./Target./Input./Profiler./Log.
+ *      — the service host owns these; leave them on the original channel.
+ *
+ * Pure (no I/O). The hook script inlines an equivalent prefix test driven by the
+ * same `RENDER_DOMAIN_PREFIXES` literal, so the two cannot silently drift.
+ */
+export declare function routeByDomain(method: string): CdpRoute;
+/** True for an event method we re-inject from the render guest into the panel. */
+export declare function isRenderEventMethod(method: string): boolean;
+/**
+ * The JS injected into the DevTools front-end realm. Idempotent (sentinel guard).
+ * Wraps `InspectorFrontendHost.sendMessageToBackend`: a RENDER-domain command is
+ * pushed onto `globalThis.__diminaElementsOutbound` (drained by main) and NOT
+ * forwarded to the original embedder channel (main answers it from the render
+ * guest); every other command calls through to the original (service-host path).
+ *
+ * Returns `'installed'` / `'already'` on success, `'partial'` while the embedder
+ * global is not yet present (so the caller retries), `'error:…'` on a real fault.
+ */
+export declare function buildElementsHookScript(): string;
+export interface ElementsForwardDeps {
+    /** The wc hosting the right-panel Chrome DevTools FRONT-END (injection target). */
+    devtoolsWc: WebContents;
+    /** Router handle — resolves the active render guest + render-event stream. */
+    bridge: BridgeRouterHandle;
+    /**
+     * The app whose active render guest we route to. `undefined` means "the
+     * router's current app" (resolved fresh on every use, like the safe-area /
+     * devtools-follow paths) — what the wire-up passes.
+     */
+    appId?: string;
+    /**
+     * Optional connection registry. When present, per-webContents teardowns
+     * (the devtools front-end wc's `stop`, and each render guest's `onDestroyed`)
+     * are routed through `connections.acquire(wc).own(cleanup)` so they fire
+     * deterministically on wc destroy / connection reset — replacing the bespoke
+     * `wc.once('destroyed', cleanup)` hook. Optional so existing callers compile
+     * unchanged; absent → the `once('destroyed')` fallback is used.
+     */
+    connections?: ConnectionRegistry;
+}
+/**
+ * Install Elements forwarding on a DevTools front-end host wc. Returns a disposer
+ * (`stop`) that clears timers, unsubscribes render events, detaches ONLY the
+ * debugger sessions this feature attached, and removes every listener it added.
+ *
+ * Best-effort + defensive throughout: a destroyed wc ends the feature; every
+ * executeJavaScript / sendCommand is wrapped so a torn-down guest never throws
+ * and an in-flight command always settles (we dispatch an error back rather than
+ * leaving the front-end pending).
+ */
+export declare function installElementsForward(deps: ElementsForwardDeps): () => void;
+//# sourceMappingURL=index.d.ts.map