@dimina-kit/devtools 0.3.2-dev.20260601115343 → 0.3.2-dev.20260610114009

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

@@ -1,12 +1,41 @@
-import { evalInSim, getSimulator, inIframe } from '../exec.js';
-import { parseLocationRoute } from '../../../../shared/simulator-route.js';
+import { evalInSim, getActivePageWc, getSimulator } from '../exec.js';
+import { decodePageSpec, parseLocationRoute } from '../../../../shared/simulator-route.js';
+import { waitForActivePage } from '../wait-active-page.js';
 export const appHandlers = {};
+/** Nav methods that take a `{ url }` arg (navigateBack is handled separately). */
+const NAV_METHODS = new Set(['navigateTo', 'redirectTo', 'reLaunch', 'switchTab']);
 // -- App domain --
 async function readRoute(ctx) {
     const { search } = await evalInSim(ctx, `({ search: location.search })`);
     return parseLocationRoute(search);
 }
+/**
+ * Native-host: derive the visible page's `{ pagePath, query }` from the active
+ * render guest. The page-stack depth isn't surfaced by the bridge handle, so the
+ * native page stack is reported as the single active page (see App.getPageStack).
+ * Reads the guest's own `location.search` — the render-host preload encodes
+ * `pagePath` (+ per-page query) there.
+ */
+async function readNativeActivePage(ctx) {
+    const renderWc = getActivePageWc(ctx);
+    if (!renderWc)
+        return null;
+    const search = await renderWc
+        .executeJavaScript('location.search')
+        .catch(() => '');
+    const params = new URLSearchParams(search.startsWith('?') ? search.slice(1) : search);
+    const pagePath = params.get('pagePath') || '';
+    if (!pagePath)
+        return null;
+    // The guest URL carries the full page spec on `pagePath` (may include `?k=v`).
+    const spec = decodePageSpec(pagePath);
+    return { pagePath: spec.pagePath, query: spec.query };
+}
 appHandlers['App.getCurrentPage'] = async (ctx) => {
+    if (ctx.bridge?.isNativeHost()) {
+        const page = await readNativeActivePage(ctx);
+        return { pageId: 1, path: page?.pagePath ?? '', query: page?.query ?? {} };
+    }
     const route = await readRoute(ctx);
     const iframeCount = await evalInSim(ctx, `document.querySelectorAll('iframe').length`);
     return {
@@ -16,8 +45,28 @@ appHandlers['App.getCurrentPage'] = async (ctx) => {
     };
 };
 appHandlers['App.getPageStack'] = async (ctx) => {
-    const route = await readRoute(ctx);
     const pageStack = [];
+    if (ctx.bridge?.isNativeHost()) {
+        // DeviceShell reports its full ordered stack (bottom→top) via PAGE_STACK;
+        // the bridge stores it. Report that. Before the first signal (or in a mock
+        // without the accessor) fall back to the single visible page.
+        const stack = ctx.bridge.getPageStack?.();
+        if (stack && stack.length > 0) {
+            stack.forEach((entry, i) => {
+                pageStack.push({
+                    pageId: i + 1,
+                    path: entry.pagePath,
+                    query: Object.fromEntries(Object.entries(entry.query ?? {}).map(([k, v]) => [k, String(v)])),
+                });
+            });
+            return { pageStack };
+        }
+        const page = await readNativeActivePage(ctx);
+        if (page)
+            pageStack.push({ pageId: 1, path: page.pagePath, query: page.query });
+        return { pageStack };
+    }
+    const route = await readRoute(ctx);
     if (!route)
         return { pageStack };
     // Mirrors upstream HashRouter.parseSearch: `[entry]` or `[entry, current]`.
@@ -30,24 +79,88 @@ appHandlers['App.getPageStack'] = async (ctx) => {
 appHandlers['App.callWxMethod'] = async (ctx, params) => {
     const method = params.method;
     const args = params.args || [];
+    // NATIVE-HOST: the authoritative `wx.*` runs in the hidden service-host
+    // window (the simulator / render-guest context has no `wx`). Run EVERY method
+    // there — nav so the page stack goes through the real runtime path, and
+    // non-nav (setNavigationBarTitle / getSystemInfoSync / tabBar APIs / …) so
+    // they don't fall through to the default-arch eval-in-simulator path below,
+    // which throws "wx is not defined" under native-host.
+    if (ctx.bridge?.isNativeHost()) {
+        const serviceWc = ctx.bridge.getServiceWc();
+        if (!serviceWc)
+            throw new Error('Service host not connected');
+        if (NAV_METHODS.has(method) || method === 'navigateBack') {
+            const arg = method === 'navigateBack'
+                ? (args[0] ?? { delta: 1 })
+                : (args[0] ?? {});
+            // Capture the active page BEFORE navigating so we can wait for it to
+            // actually change, instead of blindly sleeping a fixed duration.
+            const since = ctx.bridge.getActiveBridgeId();
+            await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
+            // Wait for the bridge's `activePage` signal (the new page mounted), with a
+            // timeout floor = the old blind-wait duration. Resolves as soon as the new
+            // page is active — far faster than the fixed sleep for the common case —
+            // and still bounded for edges (e.g. switchTab back to an already-mounted
+            // tab keeps the same bridgeId, so it falls through to the floor, same as
+            // the old behaviour). See wait-active-page.ts.
+            const timeoutMs = method === 'navigateBack' ? 1500 : 2000;
+            await waitForActivePage(ctx.bridge, {
+                since,
+                timeoutMs,
+                onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms — proceeding on timeout floor`),
+            });
+            return { result: undefined };
+        }
+        // Non-nav: invoke on the service-host wx and return its (sync) value. Async
+        // methods that report via a success callback return undefined here, same as
+        // the default-arch generic path below.
+        const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
+        const result = await serviceWc.executeJavaScript(`
+      new Promise((resolve, reject) => {
+        try {
+          if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
+            reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+            return
+          }
+          resolve(wx.${method}(${argsStr}))
+        } catch (e) { reject(e && e.message ? e.message : String(e)) }
+      })
+    `);
+        return { result };
+    }
     // For navigation methods, handle specially via DOM click / wx.* on the iframe
     if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab'].includes(method)) {
         const opts = args[0];
         const url = opts?.url;
         if (url) {
             const cleanUrl = url.startsWith('/') ? url : `/${url}`;
-            // Try clicking a matching DOM element first
-            const clicked = await evalInSim(ctx, inIframe(`
+            // Try clicking a matching DOM element first. We can't use `inIframe`
+            // here — tabBar mini-apps keep prior tabs' iframes around (display:none)
+            // and `iframes[length-1]` ends up being the hidden, freshly-cached tab
+            // rather than the visible one. Pick the visible iframe explicitly.
+            const clicked = await evalInSim(ctx, `(() => {
+        const iframes = Array.from(document.querySelectorAll('iframe'))
+        const visible = iframes.filter((f) => {
+          const cs = window.getComputedStyle(f)
+          if (cs.display === 'none' || cs.visibility === 'hidden') return false
+          const rect = f.getBoundingClientRect()
+          return rect.width > 0 && rect.height > 0
+        })
+        const target = visible[visible.length - 1] || iframes[iframes.length - 1]
+        if (!target || !target.contentDocument) return false
         const path = ${JSON.stringify(cleanUrl)}
-        const el = Array.from(_doc.querySelectorAll('[data-path]'))
-          .find(e => e.getAttribute('data-path') === path)
+        const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
+          .find((e) => e.getAttribute('data-path') === path)
         if (el) { el.click(); return true }
         return false
-      `)).catch(() => false);
+      })()`).catch(() => false);
             if (!clicked) {
-                // Fallback: drive navigation via wx.* on the rendered page iframe.
-                // Upstream's query router doesn't react to URL mutation; the active
-                // page's iframe exposes wx.* with the live dimina runtime bindings.
+                // Fallback cascade for navigation methods:
+                //   1. iframe wx[method] — page-iframe surface (older arch, where
+                //      jdimina installed `window.wx` on each page frame).
+                //   2. top-window wx[method] — set up by simulator/main.tsx, binds
+                //      MiniApp.switchTab / navigateTo / etc. Required for switchTab
+                //      since page-iframe wx (jdimina) doesn't expose it.
                 const apiName = JSON.stringify(method);
                 const urlJson = JSON.stringify(cleanUrl);
                 await evalInSim(ctx, `(() => {
@@ -60,6 +173,9 @@ appHandlers['App.callWxMethod'] = async (ctx, params) => {
                 }
               } catch (_) {}
             }
+            if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
+              wx[${apiName}]({ url: ${urlJson} })
+            }
           })()`);
             }
             // Wait for navigation

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