@dimina-kit/devtools 0.3.0 → 0.3.1-dev.20260515105504

package/dist/main/utils/sender-policy.js

@@ -0,0 +1,42 @@
+/**
+ * Default workbench sender white-list.
+ *
+ * An IPC message is accepted only when its `event.sender` matches one of
+ * the WebContents the main process itself created and trusts:
+ * - the main window's renderer
+ * - the optional workbench settings BrowserWindow's renderer (when open)
+ * - the settings overlay view (when open)
+ * - the popover overlay view (when open)
+ *
+ * The simulator webview is intentionally NOT on this list: its preload
+ * (`src/preload/windows/simulator.ts`) uses `ipcRenderer.sendToHost`
+ * exclusively, never `invoke`/`send`, so it can't legitimately reach an
+ * ipcMain handler. Including it would only widen the attack surface if
+ * the guest were ever compromised.
+ *
+ * Any other sender — including a stale/destroyed sender or an unknown
+ * iframe — is rejected.
+ */
+export function createWorkbenchSenderPolicy(ctx) {
+    return (sender) => {
+        if (sender.isDestroyed())
+            return false;
+        // Main window renderer
+        if (ctx.windows.isMainSender(sender.id))
+            return true;
+        // Standalone settings BrowserWindow renderer
+        if (ctx.windows.isSettingsWindowSender(sender.id))
+            return true;
+        // Settings overlay view (mounted inside the main window)
+        const settingsViewId = ctx.views.getSettingsWebContentsId();
+        if (settingsViewId != null && sender.id === settingsViewId)
+            return true;
+        // Popover overlay view
+        const popoverViewId = ctx.views.getPopoverWebContentsId();
+        if (popoverViewId != null && sender.id === popoverViewId)
+            return true;
+        // simulator preload uses sendToHost only; never reaches ipcMain handlers.
+        return false;
+    };
+}
+//# sourceMappingURL=sender-policy.js.map

package/dist/main/windows/main-window/create.d.ts

@@ -6,6 +6,12 @@ export interface WindowOptions {
     minWidth?: number;
     minHeight?: number;
     indexHtml: string;
+    /**
+     * Absolute path to the simulator preload bundle. Registered at the session
+     * level so every frame inside the simulator <webview> gets the preload that
+     * exposes the `wx` runtime to the mini-program.
+     */
+    simulatorPreloadPath: string;
 }
 export declare function createMainWindow(opts: WindowOptions): BrowserWindow;
 //# sourceMappingURL=create.d.ts.map

package/dist/main/windows/main-window/create.js

@@ -1,12 +1,21 @@
-import { app, BrowserWindow, View, globalShortcut, session } from 'electron';
+import { app, BrowserWindow, View, session, shell } from 'electron';
+import path from 'path';
 import { getSimulatorServicewechatReferer } from '../../services/simulator/referer.js';
+import { mainPreloadPath } from '../../utils/paths.js';
 import { themeBg } from '../../utils/theme.js';
+import { applyNavigationHardening, handleWindowOpenExternal, } from '../navigation-hardening.js';
 let simulatorSessionConfigured = false;
-function configureSimulatorSession() {
+function configureSimulatorSession(simulatorPreloadPath) {
     if (simulatorSessionConfigured)
         return;
     simulatorSessionConfigured = true;
     const simulatorSession = session.fromPartition('persist:simulator');
+    // Inject the simulator preload on every frame in this session. This is the
+    // mini-program runtime entry point (exposes `wx`, page registers, etc.).
+    simulatorSession.registerPreloadScript({
+        type: 'frame',
+        filePath: simulatorPreloadPath,
+    });
     simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
         const forcedReferer = getSimulatorServicewechatReferer();
         if (forcedReferer) {
@@ -25,7 +34,7 @@ function configureSimulatorSession() {
     });
 }
 export function createMainWindow(opts) {
-    configureSimulatorSession();
+    configureSimulatorSession(opts.simulatorPreloadPath);
     const mainWindow = new BrowserWindow({
         width: opts.width ?? 1280,
         height: opts.height ?? 980,
@@ -35,8 +44,13 @@ export function createMainWindow(opts) {
         show: false,
         backgroundColor: themeBg(),
         webPreferences: {
-            nodeIntegration: true,
-            contextIsolation: false,
+            nodeIntegration: false,
+            contextIsolation: true,
+            // `sandbox: false` is required so the preload bundle can `require('electron')`
+            // to access contextBridge/ipcRenderer. The renderer itself runs isolated.
+            sandbox: false,
+            preload: mainPreloadPath,
+            // The simulator <webview> still relies on the webview tag; keep it enabled.
             webviewTag: true,
         },
     });
@@ -51,17 +65,59 @@ export function createMainWindow(opts) {
             }
         }
     });
-    mainWindow.webContents.on('will-attach-webview', (_event, webPreferences) => {
+    const rendererDir = path.dirname(opts.indexHtml);
+    // Restrict the main renderer to file:// URLs under the renderer bundle and
+    // route every popup through the OS browser. See navigation-hardening.ts.
+    applyNavigationHardening(mainWindow.webContents, rendererDir);
+    mainWindow.webContents.on('will-attach-webview', (event, webPreferences, params) => {
+        // Pin the simulator <webview> onto `persist:simulator` so it shares storage
+        // with the rest of the session and picks up the session-registered preload.
+        // Empirically (Electron 41) `webPreferences.partition` is the field the
+        // guest session actually consults; `params.partition` alone is a no-op,
+        // so we write both belt-and-braces.
+        ;
+        webPreferences.partition = 'persist:simulator';
+        params.partition = 'persist:simulator';
+        // The simulator <webview> intentionally runs with `contextIsolation: false`
+        // because the dimina runtime and the user-authored preload scripts share
+        // the same JavaScript realm as the page — the mini-program SDK reaches
+        // into the page's globals (e.g. AudioContext, custom registers) and
+        // attaches helpers via window-level injection. Flipping isolation on
+        // would break that contract.
         webPreferences.contextIsolation = false;
+        void event;
+    });
+    // The simulator webview's webContents only exists once attached; wire its
+    // window-open / will-navigate handlers here so popups + redirects don't
+    // pivot to file:// or arbitrary origins.
+    mainWindow.webContents.on('did-attach-webview', (_event, webviewWebContents) => {
+        webviewWebContents.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+        webviewWebContents.on('will-navigate', (e, url) => {
+            try {
+                const u = new URL(url);
+                // Allow the simulator's own host (localhost dev server) plus the
+                // initial about:blank that Chromium uses before src loads.
+                if (u.protocol === 'about:')
+                    return;
+                if ((u.protocol === 'http:' || u.protocol === 'https:') &&
+                    (u.hostname === 'localhost' || u.hostname === '127.0.0.1')) {
+                    return;
+                }
+                e.preventDefault();
+                if (u.protocol === 'http:' || u.protocol === 'https:') {
+                    void shell.openExternal(url);
+                }
+            }
+            catch {
+                e.preventDefault();
+            }
+        });
     });
     mainWindow.loadFile(opts.indexHtml);
     const container = new View();
     const mainWebView = mainWindow.contentView;
     container.addChildView(mainWebView);
     mainWindow.contentView = container;
-    globalShortcut.register('CommandOrControl+Shift+I', () => {
-        mainWindow.webContents.openDevTools({ mode: 'detach' });
-    });
     return mainWindow;
 }
 //# sourceMappingURL=create.js.map

package/dist/main/windows/main-window/events.d.ts

@@ -1,9 +1,10 @@
 import type { BrowserWindow } from 'electron';
 import type { WorkbenchContext } from '../../services/workbench-context.js';
+import { type Disposable } from '../../utils/disposable.js';
 export interface MainWindowEventState {
     context?: WorkbenchContext;
     onResize?: () => void;
     onClose?: (event: Electron.Event) => void | Promise<void>;
 }
-export declare function wireMainWindowEvents(win: BrowserWindow, state?: MainWindowEventState): void;
+export declare function wireMainWindowEvents(win: BrowserWindow, state?: MainWindowEventState): Disposable;
 //# sourceMappingURL=events.d.ts.map

package/dist/main/windows/main-window/events.js

@@ -1,4 +1,7 @@
+import { globalShortcut } from 'electron';
+import { DisposableRegistry, toDisposable } from '../../utils/disposable.js';
 export function wireMainWindowEvents(win, state = {}) {
+    const registry = new DisposableRegistry();
     const mainWebView = win.contentView.children[0];
     const resizeMainWebView = () => {
         if (mainWebView) {
@@ -9,10 +12,30 @@ export function wireMainWindowEvents(win, state = {}) {
     };
     resizeMainWebView();
     win.on('resize', resizeMainWebView);
+    registry.add(toDisposable(() => {
+        win.removeListener('resize', resizeMainWebView);
+    }));
     if (state.onClose) {
-        win.on('close', (event) => {
+        const onCloseHandler = (event) => {
             void state.onClose?.(event);
-        });
+        };
+        win.on('close', onCloseHandler);
+        registry.add(toDisposable(() => {
+            win.removeListener('close', onCloseHandler);
+        }));
     }
+    // DevTools shortcut: scoped to this main window so its disposal is tied
+    // to ctx.registry. `unregisterAll()` in lifecycle remains as a process-exit
+    // safety net.
+    const devToolsAccelerator = 'CommandOrControl+Shift+I';
+    const registered = globalShortcut.register(devToolsAccelerator, () => {
+        win.webContents.openDevTools({ mode: 'detach' });
+    });
+    if (registered) {
+        registry.add(toDisposable(() => {
+            globalShortcut.unregister(devToolsAccelerator);
+        }));
+    }
+    return registry;
 }
 //# sourceMappingURL=events.js.map

package/dist/main/windows/navigation-hardening.d.ts

@@ -0,0 +1,24 @@
+import type { WebContents } from 'electron';
+/**
+ * Navigation hardening for every WebContents created by the host application
+ * (main window renderer, settings overlay, popover overlay, standalone
+ * settings window). These WebContents load the contextBridge-exposing main
+ * preload, so an unintended navigation out of the renderer bundle would
+ * expose `window.devtools.ipc` to a foreign origin.
+ *
+ * `applyNavigationHardening` installs:
+ *  - `setWindowOpenHandler`: deny popups; route http(s) through the OS browser.
+ *  - `will-navigate`: cancel any in-place navigation outside `rendererDir`;
+ *    route http(s) through the OS browser.
+ */
+/** Default popup handler: open http(s) externally, deny everything else. */
+export declare function handleWindowOpenExternal(url: string): {
+    action: 'deny';
+};
+/**
+ * Install `setWindowOpenHandler` + `will-navigate` on `wc` so it can only
+ * navigate to `file://` URLs under `rendererDir`. Safe to call once per
+ * WebContents.
+ */
+export declare function applyNavigationHardening(wc: WebContents, rendererDir: string): void;
+//# sourceMappingURL=navigation-hardening.d.ts.map

package/dist/main/windows/navigation-hardening.js

@@ -0,0 +1,55 @@
+import { shell } from 'electron';
+import path from 'path';
+import { pathToFileURL } from 'url';
+/**
+ * Navigation hardening for every WebContents created by the host application
+ * (main window renderer, settings overlay, popover overlay, standalone
+ * settings window). These WebContents load the contextBridge-exposing main
+ * preload, so an unintended navigation out of the renderer bundle would
+ * expose `window.devtools.ipc` to a foreign origin.
+ *
+ * `applyNavigationHardening` installs:
+ *  - `setWindowOpenHandler`: deny popups; route http(s) through the OS browser.
+ *  - `will-navigate`: cancel any in-place navigation outside `rendererDir`;
+ *    route http(s) through the OS browser.
+ */
+/** Default popup handler: open http(s) externally, deny everything else. */
+export function handleWindowOpenExternal(url) {
+    try {
+        const u = new URL(url);
+        if (u.protocol === 'http:' || u.protocol === 'https:') {
+            void shell.openExternal(url);
+        }
+    }
+    catch {
+        /* malformed URL — fall through to deny */
+    }
+    return { action: 'deny' };
+}
+/**
+ * Install `setWindowOpenHandler` + `will-navigate` on `wc` so it can only
+ * navigate to `file://` URLs under `rendererDir`. Safe to call once per
+ * WebContents.
+ */
+export function applyNavigationHardening(wc, rendererDir) {
+    const rendererPrefix = pathToFileURL(rendererDir + path.sep).href;
+    wc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+    wc.on('will-navigate', (event, url) => {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            event.preventDefault();
+            return;
+        }
+        if (parsed.protocol === 'file:' && parsed.href.startsWith(rendererPrefix)) {
+            return;
+        }
+        event.preventDefault();
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            void shell.openExternal(url);
+        }
+    });
+}
+//# sourceMappingURL=navigation-hardening.js.map

package/dist/main/windows/settings-window/create.js

@@ -1,6 +1,8 @@
 import { BrowserWindow } from 'electron';
 import path from 'path';
+import { mainPreloadPath } from '../../utils/paths.js';
 import { themeBg } from '../../utils/theme.js';
+import { applyNavigationHardening } from '../navigation-hardening.js';
 export async function createSettingsWindow(parent, rendererDir) {
     const win = new BrowserWindow({
         width: 420,
@@ -10,8 +12,16 @@ export async function createSettingsWindow(parent, rendererDir) {
         parent: parent ?? undefined,
         title: '开发工具设置',
         backgroundColor: themeBg(),
-        webPreferences: { nodeIntegration: true, contextIsolation: false },
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
     });
+    // Standalone settings window loads mainPreloadPath, so the same
+    // navigation rules as the main window apply — see navigation-hardening.ts.
+    applyNavigationHardening(win.webContents, rendererDir);
     await win.loadFile(path.join(rendererDir, 'entries/workbench-settings/index.html'));
     return win;
 }

package/dist/preload/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Public preload API surface for `@dimina-kit/devtools/preload`.
+ *
+ * External consumers compose their own simulator <webview> preload by
+ * importing the `install*` helpers from here. The built-in simulator
+ * preload at `windows/simulator.ts` is one such composition.
+ *
+ * NOTE: do NOT add main-window preload concerns (contextBridge / ipc
+ * exposure) to this file — that lives in `windows/main.ts` and is
+ * bundled by esbuild, never re-exported through this barrel.
+ */
+export { installConsoleInstrumentation } from './instrumentation/console.js';
+export { installAppDataInstrumentation, sendAllAppData } from './instrumentation/app-data.js';
+export { installWxmlInstrumentation, sendWxmlTree, setupWxmlObserver } from './instrumentation/wxml.js';
+export { installSimulatorBridge } from './runtime/bridge.js';
+export { setupApiCompatHook } from './shared/api-compat.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/preload/index.js

@@ -0,0 +1,17 @@
+/**
+ * Public preload API surface for `@dimina-kit/devtools/preload`.
+ *
+ * External consumers compose their own simulator <webview> preload by
+ * importing the `install*` helpers from here. The built-in simulator
+ * preload at `windows/simulator.ts` is one such composition.
+ *
+ * NOTE: do NOT add main-window preload concerns (contextBridge / ipc
+ * exposure) to this file — that lives in `windows/main.ts` and is
+ * bundled by esbuild, never re-exported through this barrel.
+ */
+export { installConsoleInstrumentation } from './instrumentation/console.js';
+export { installAppDataInstrumentation, sendAllAppData } from './instrumentation/app-data.js';
+export { installWxmlInstrumentation, sendWxmlTree, setupWxmlObserver } from './instrumentation/wxml.js';
+export { installSimulatorBridge } from './runtime/bridge.js';
+export { setupApiCompatHook } from './shared/api-compat.js';
+//# sourceMappingURL=index.js.map

package/dist/preload/instrumentation/app-data.js

@@ -1,15 +1,69 @@
 import { SimulatorChannel, BridgeChannel } from '../../shared/ipc-channels.js';
-import { sendToHost } from '../runtime/host.js';
-import { simulatorBridge, clearAppDataSnapshot, setAppDataSnapshot, } from '../runtime/bridge.js';
+import { onHostMessage, sendToHost } from '../runtime/host.js';
+import { clearAppDataSnapshot, setAppDataSnapshot, } from '../runtime/bridge.js';
 import { createDisposableSet } from './disposable.js';
 const appDataCache = new Map();
+// Bridges in insertion order — drives the `bridges` array in snapshots so
+// renderer tabs render in a stable, chronological sequence.
+const bridgeOrder = [];
+// Page path per bridge: set from `page_*` init's body.path. Component init
+// also carries a path but it's the component's own path, not the page route.
+const bridgePagePath = new Map();
+function recordBridge(bridgeId) {
+    if (!bridgeOrder.includes(bridgeId))
+        bridgeOrder.push(bridgeId);
+}
+function buildSnapshot() {
+    const bridges = [];
+    for (const id of bridgeOrder) {
+        bridges.push({ id, pagePath: bridgePagePath.get(id) ?? null });
+    }
+    const entries = {};
+    for (const [key, entry] of appDataCache) {
+        const slash = key.indexOf('/');
+        if (slash < 0)
+            continue;
+        const bridgeId = key.slice(0, slash);
+        const moduleId = key.slice(slash + 1);
+        if (!entries[bridgeId])
+            entries[bridgeId] = {};
+        const displayKey = entry.componentPath ?? moduleId;
+        entries[bridgeId][displayKey] = entry.data;
+    }
+    return { bridges, entries };
+}
 function publishSnapshot() {
     const data = {};
-    for (const [key, value] of appDataCache) {
-        data[key] = value;
+    for (const [key, entry] of appDataCache) {
+        data[key] = entry.data;
     }
     setAppDataSnapshot(data);
 }
+function clearBridge(bridgeId) {
+    const prefix = `${bridgeId}/`;
+    for (const key of [...appDataCache.keys()]) {
+        if (key.startsWith(prefix))
+            appDataCache.delete(key);
+    }
+    const idx = bridgeOrder.indexOf(bridgeId);
+    if (idx >= 0)
+        bridgeOrder.splice(idx, 1);
+    bridgePagePath.delete(bridgeId);
+    publishSnapshot();
+    // Push a refreshed snapshot so the renderer can drop the evicted bridge
+    // immediately, without waiting for the user to hit the refresh button.
+    sendToHost(SimulatorChannel.AppDataAll, buildSnapshot());
+}
+// dimina runtime emits two kinds of service→main messages relevant to the
+// AppData panel:
+//  • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
+//    where each `data` is a partial setData patch.
+//  • instance init: type === instance id (prefixed `page_`/`component_`),
+//    body `{bridgeId, path, data}` with the COMPLETE initial state.
+//
+// Policy: surface PAGE entries only. Component entries are dropped — they
+// sometimes flow on a bridge id distinct from their owning page's and never
+// receive pageUnload, which would manifest as ghost tabs in the panel.
 function decodeWorkerMessage(message) {
     let payload = message;
     if (typeof payload === 'string') {
@@ -20,10 +74,73 @@ function decodeWorkerMessage(message) {
             return null;
         }
     }
+    if (!payload || typeof payload !== 'object')
+        return null;
     const record = payload;
-    if (record?.type !== 'u' || !record.body)
+    if (record.type === 'ub') {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || !Array.isArray(body.updates))
+            return null;
+        const out = [];
+        for (const u of body.updates) {
+            if (!u || typeof u.moduleId !== 'string')
+                continue;
+            if (!u.moduleId.startsWith('page_'))
+                continue;
+            out.push({ mode: 'patch', bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data });
+        }
+        return out.length > 0 ? out : null;
+    }
+    if (typeof record.type === 'string' && record.type.startsWith('page_')) {
+        const body = record.body;
+        if (!body || typeof body !== 'object')
+            return null;
+        if (typeof body.bridgeId !== 'string' || typeof body.path !== 'string')
+            return null;
+        if (!body.data || typeof body.data !== 'object')
+            return null;
+        return [{
+                mode: 'init',
+                bridgeId: body.bridgeId,
+                moduleId: record.type,
+                componentPath: body.path,
+                data: body.data,
+            }];
+    }
+    return null;
+}
+// main→worker direction: container signals page teardown so cache can evict.
+function decodeOutgoingMessage(message) {
+    let payload = message;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const r = payload;
+    if (typeof r.type !== 'string')
         return null;
-    return record.body;
+    return {
+        type: r.type,
+        bridgeId: typeof r.body?.bridgeId === 'string' ? r.body.bridgeId : undefined,
+    };
+}
+function instrumentPostMessage(worker) {
+    const orig = worker.postMessage.bind(worker);
+    worker.postMessage = function (msg, ...rest) {
+        const decoded = decodeOutgoingMessage(msg);
+        if (decoded?.type === 'pageUnload' && decoded.bridgeId) {
+            clearBridge(decoded.bridgeId);
+        }
+        return orig(msg, ...rest);
+    };
 }
 function createInstrumentedWorker(OriginalWorker) {
     function InstrumentedWorker(scriptURL, options) {
@@ -31,15 +148,22 @@ function createInstrumentedWorker(OriginalWorker) {
             ? scriptURL
             : new URL(scriptURL, window.location.href);
         const worker = Reflect.construct(OriginalWorker, [resolvedScriptURL, options], new.target ?? InstrumentedWorker);
+        instrumentPostMessage(worker);
         worker.addEventListener('message', (event) => {
-            const body = decodeWorkerMessage(event.data);
-            if (!body)
+            const entries = decodeWorkerMessage(event.data);
+            if (!entries)
                 return;
-            window.__simulatorHook?.appData({
-                bridgeId: body.bridgeId,
-                moduleId: body.moduleId,
-                data: body.data,
-            });
+            for (const entry of entries) {
+                const hookBody = {
+                    bridgeId: entry.bridgeId,
+                    moduleId: entry.moduleId,
+                    data: entry.data,
+                    mode: entry.mode,
+                };
+                if (entry.mode === 'init')
+                    hookBody.componentPath = entry.componentPath;
+                window.__simulatorHook?.appData(hookBody);
+            }
         });
         return worker;
     }
@@ -57,12 +181,44 @@ export function installAppDataInstrumentation() {
     window.__simulatorHook = {
         appData: (body) => {
             const record = body;
-            if (record?.bridgeId && record?.moduleId) {
-                const key = `${record.bridgeId}/${record.moduleId}`;
-                appDataCache.set(key, record.data);
-                publishSnapshot();
+            if (!record?.bridgeId || !record?.moduleId)
+                return;
+            // R6: drop ub patches whose bridge has never been initialised. dimina
+            // dispatches pageUnload to the service worker, which fires onUnload —
+            // and onUnload's setData (e.g. console-test's stopTimer) produces a
+            // late `ub` that arrives AFTER our clearBridge. Without this gate the
+            // late patch would resurrect the unloaded bridge as a ghost tab.
+            if (record.mode !== 'init' && !bridgePagePath.has(record.bridgeId))
+                return;
+            const key = `${record.bridgeId}/${record.moduleId}`;
+            const prev = appDataCache.get(key);
+            const incoming = (record.data && typeof record.data === 'object'
+                ? record.data
+                : {});
+            // init = full-state replace; patch = merge into previous (setData semantics)
+            const merged = record.mode === 'init'
+                ? { ...incoming }
+                : { ...(prev?.data ?? {}), ...incoming };
+            const componentPath = record.componentPath ?? prev?.componentPath;
+            const next = componentPath !== undefined
+                ? { componentPath, data: merged }
+                : { data: merged };
+            appDataCache.set(key, next);
+            recordBridge(record.bridgeId);
+            if (record.mode === 'init'
+                && record.moduleId.startsWith('page_')
+                && record.componentPath) {
+                bridgePagePath.set(record.bridgeId, record.componentPath);
             }
-            sendToHost(SimulatorChannel.AppData, body);
+            publishSnapshot();
+            const payload = {
+                bridgeId: record.bridgeId,
+                moduleId: record.moduleId,
+                data: merged,
+            };
+            if (componentPath !== undefined)
+                payload.componentPath = componentPath;
+            sendToHost(SimulatorChannel.AppData, payload);
         },
     };
     Object.defineProperty(window, 'Worker', {
@@ -70,6 +226,7 @@ export function installAppDataInstrumentation() {
         writable: true,
         value: createInstrumentedWorker(OriginalWorker),
     });
+    disposables.add(onHostMessage(BridgeChannel.AppDataGetAllRequest, () => sendAllAppData()));
     publishSnapshot();
     disposables.add(() => {
         if (originalDescriptor) {
@@ -89,6 +246,8 @@ export function installAppDataInstrumentation() {
     });
     disposables.add(() => {
         appDataCache.clear();
+        bridgeOrder.length = 0;
+        bridgePagePath.clear();
         clearAppDataSnapshot();
         publishSnapshot();
     });
@@ -98,6 +257,6 @@ export function installAppDataInstrumentation() {
 }
 export function sendAllAppData() {
     publishSnapshot();
-    sendToHost(BridgeChannel.AppDataGetAllResponse, simulatorBridge.appdata.data);
+    sendToHost(SimulatorChannel.AppDataAll, buildSnapshot());
 }
 //# sourceMappingURL=app-data.js.map