@dimina-kit/devtools 0.3.1-dev.20260518114324 → 0.3.2-dev.20260522085907

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

@@ -1,10 +1,11 @@
 import { app, nativeTheme } from 'electron';
 import fs from 'fs';
 import path from 'path';
+import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
 const DEFAULTS = {
     cdp: {
         enabled: false,
-        port: 9222,
+        port: DEFAULT_CDP_PORT,
     },
     mcp: {
         enabled: false,

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

@@ -204,6 +204,35 @@ export function setupSimulatorStorage(host, options) {
         }
         return { securityOrigin: cachedOrigin, isLocalStorage: true };
     }
+    async function withStorageWrite(fn) {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed()) {
+            return { ok: false, error: 'simulator not attached' };
+        }
+        const storageId = await getStorageId();
+        if (!storageId)
+            return { ok: false, error: 'failed to resolve simulator origin' };
+        try {
+            return await fn({ wc: attachedWc, storageId });
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+    async function withStorageRead(fallback, fn) {
+        await ensureAttached();
+        if (!attachedWc || attachedWc.isDestroyed())
+            return fallback;
+        try {
+            const storageId = await getStorageId();
+            if (!storageId)
+                return fallback;
+            return await fn({ wc: attachedWc, storageId });
+        }
+        catch {
+            return fallback;
+        }
+    }
     /**
      * Push a storage event synthesised from the write path itself, in addition
      * to whatever CDP forwards via `DOMStorage.domStorageItem*`. The CDP
@@ -228,109 +257,53 @@ export function setupSimulatorStorage(host, options) {
         host.send(SimulatorStorageChannel.Event, evt);
     }
     async function setItem(key, value) {
-        await ensureAttached();
-        if (!attachedWc || attachedWc.isDestroyed()) {
-            return { ok: false, error: 'simulator not attached' };
-        }
-        const storageId = await getStorageId();
-        if (!storageId)
-            return { ok: false, error: 'failed to resolve simulator origin' };
-        try {
-            await attachedWc.debugger.sendCommand('DOMStorage.setDOMStorageItem', {
-                storageId,
-                key,
-                value,
-            });
+        return withStorageWrite(async ({ wc, storageId }) => {
+            await wc.debugger.sendCommand('DOMStorage.setDOMStorageItem', { storageId, key, value });
             pushSyntheticEvent({ type: 'added', key, newValue: value });
             return { ok: true };
-        }
-        catch (e) {
-            return { ok: false, error: e.message };
-        }
+        });
     }
     async function removeItem(key) {
-        await ensureAttached();
-        if (!attachedWc || attachedWc.isDestroyed()) {
-            return { ok: false, error: 'simulator not attached' };
-        }
-        const storageId = await getStorageId();
-        if (!storageId)
-            return { ok: false, error: 'failed to resolve simulator origin' };
-        try {
-            await attachedWc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', {
-                storageId,
-                key,
-            });
+        return withStorageWrite(async ({ wc, storageId }) => {
+            await wc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', { storageId, key });
             pushSyntheticEvent({ type: 'removed', key });
             return { ok: true };
-        }
-        catch (e) {
-            return { ok: false, error: e.message };
-        }
+        });
     }
     // Scoped clear: when an appId is active, removes only its prefixed keys so
     // we don't nuke other projects' state sharing the simulator partition.
     // Falls back to origin-wide `DOMStorage.clear` only when no active appId is
     // set (matches the snapshot filter's documented null-fallback).
     async function clearScoped() {
-        await ensureAttached();
-        if (!attachedWc || attachedWc.isDestroyed()) {
-            return { ok: false, error: 'simulator not attached' };
-        }
-        const storageId = await getStorageId();
-        if (!storageId)
-            return { ok: false, error: 'failed to resolve simulator origin' };
-        const prefix = activePrefix();
-        try {
+        return withStorageWrite(async ({ wc, storageId }) => {
+            const prefix = activePrefix();
             if (!prefix) {
-                await attachedWc.debugger.sendCommand('DOMStorage.clear', { storageId });
+                await wc.debugger.sendCommand('DOMStorage.clear', { storageId });
                 return { ok: true };
             }
-            const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
+            const result = (await wc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
                 storageId,
             }));
             for (const [key] of result.entries) {
                 if (!key.startsWith(prefix))
                     continue;
-                await attachedWc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', {
-                    storageId,
-                    key,
-                });
+                await wc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', { storageId, key });
             }
             return { ok: true };
-        }
-        catch (e) {
-            return { ok: false, error: e.message };
-        }
+        });
     }
     // Origin-wide clear regardless of the active appId — wipes every project's
     // state in the shared simulator partition. The renderer guards this with a
     // confirm dialog; we don't second-guess here.
     async function clearAll() {
-        await ensureAttached();
-        if (!attachedWc || attachedWc.isDestroyed()) {
-            return { ok: false, error: 'simulator not attached' };
-        }
-        const storageId = await getStorageId();
-        if (!storageId)
-            return { ok: false, error: 'failed to resolve simulator origin' };
-        try {
-            await attachedWc.debugger.sendCommand('DOMStorage.clear', { storageId });
+        return withStorageWrite(async ({ wc, storageId }) => {
+            await wc.debugger.sendCommand('DOMStorage.clear', { storageId });
             return { ok: true };
-        }
-        catch (e) {
-            return { ok: false, error: e.message };
-        }
+        });
     }
     async function getSnapshot() {
-        await ensureAttached();
-        if (!attachedWc || attachedWc.isDestroyed())
-            return [];
-        try {
-            const storageId = await getStorageId();
-            if (!storageId)
-                return [];
-            const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
+        return withStorageRead([], async ({ wc, storageId }) => {
+            const result = (await wc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
                 storageId,
             }));
             const prefix = activePrefix();
@@ -340,10 +313,7 @@ export function setupSimulatorStorage(host, options) {
             // Keys are returned with their `${appId}_` prefix intact; stripping is
             // a follow-up so the panel UI can stay compatible with the raw keys.
             return filtered.map(([key, value]) => ({ key, value }));
-        }
-        catch {
-            return [];
-        }
+        });
     }
     // Attach to any simulator webview that already exists (project may have
     // been opened before this function runs).

package/dist/main/services/views/view-manager.d.ts

@@ -5,7 +5,7 @@ import { type WorkbenchContext } from '../workbench-context.js';
  * full WorkbenchContext here; typing it this way documents the actual dependency.
  */
 export interface ViewManagerContext {
-    mainWindow: WorkbenchContext['mainWindow'];
+    windows: WorkbenchContext['windows'];
     rendererDir: string;
     panels: string[];
     notify: WorkbenchContext['notify'];
@@ -52,14 +52,10 @@ export interface ViewManager {
     repositionAll(): void;
     /** Destroy all overlay webContents and null out the cached views. */
     disposeAll(): void;
-    /** Log current child-view count of the main contentView. */
-    logChildViews(label: string): void;
-    /** Reposition only the simulator overlay (for simulator width changes). */
-    positionSimulator(simWidth: number): void;
-    /** Reposition only the settings overlay. */
-    positionSettings(): void;
     /** Return the webContents ID of the currently attached simulator. */
     getSimulatorWebContentsId(): number | null;
+    /** Return the live webContents of the currently attached simulator, or null. */
+    getSimulatorWebContents(): WebContents | null;
     /** Return the last known simulator width. */
     getLastSimWidth(): number;
     /** Whether the simulator overlay is currently added to the contentView. */

package/dist/main/services/views/view-manager.js

@@ -24,9 +24,9 @@ export function createViewManager(ctx) {
     function destroyViewInternal(view) {
         if (!view)
             return;
-        if (!ctx.mainWindow.isDestroyed()) {
+        if (!ctx.windows.mainWindow.isDestroyed()) {
             try {
-                ctx.mainWindow.contentView.removeChildView(view);
+                ctx.windows.mainWindow.contentView.removeChildView(view);
             }
             catch { /* already removed */ }
         }
@@ -38,21 +38,21 @@ export function createViewManager(ctx) {
         catch { /* ignore */ }
     }
     function applySimulatorBounds(simWidth) {
-        if (!simulatorView || ctx.mainWindow.isDestroyed())
+        if (!simulatorView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         simulatorView.setBounds(layout.computeSimulatorBounds(w, h, simWidth));
     }
     function applySettingsBounds() {
-        if (!settingsView || ctx.mainWindow.isDestroyed())
+        if (!settingsView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         settingsView.setBounds(layout.computeSettingsBounds(w, h));
     }
     function applyPopoverBounds() {
-        if (!popoverView || ctx.mainWindow.isDestroyed())
+        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         popoverView.setBounds(layout.computePopoverBounds(w, h));
     }
     // ── ViewManager methods ─────────────────────────────────────────────────
@@ -105,7 +105,7 @@ export function createViewManager(ctx) {
       `).catch(() => { });
         });
         if (getDefaultTab(ctx) === 'simulator') {
-            ctx.mainWindow.contentView.addChildView(simulatorView);
+            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
             simulatorViewAdded = true;
             applySimulatorBounds(simWidth);
         }
@@ -126,7 +126,7 @@ export function createViewManager(ctx) {
         if (!simulatorView)
             return;
         if (!simulatorViewAdded) {
-            ctx.mainWindow.contentView.addChildView(simulatorView);
+            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
             simulatorViewAdded = true;
         }
         applySimulatorBounds(simWidth);
@@ -134,7 +134,7 @@ export function createViewManager(ctx) {
     function hideSimulator() {
         if (simulatorView && simulatorViewAdded) {
             try {
-                ctx.mainWindow.contentView.removeChildView(simulatorView);
+                ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
             }
             catch (e) {
                 console.error('[workbench] hideSimulator error', e);
@@ -158,7 +158,7 @@ export function createViewManager(ctx) {
             await settingsView.webContents.loadFile(path.join(ctx.rendererDir, 'entries/settings/index.html'));
         }
         if (!settingsViewAdded) {
-            ctx.mainWindow.contentView.addChildView(settingsView);
+            ctx.windows.mainWindow.contentView.addChildView(settingsView);
             settingsViewAdded = true;
         }
         applySettingsBounds();
@@ -166,7 +166,7 @@ export function createViewManager(ctx) {
     function hideSettings() {
         if (settingsView && settingsViewAdded) {
             try {
-                ctx.mainWindow.contentView.removeChildView(settingsView);
+                ctx.windows.mainWindow.contentView.removeChildView(settingsView);
             }
             catch { /* ignore */ }
             settingsViewAdded = false;
@@ -186,7 +186,7 @@ export function createViewManager(ctx) {
         applyNavigationHardening(popover.webContents, ctx.rendererDir);
         popoverView = popover;
         popover.setBackgroundColor('#00000000');
-        ctx.mainWindow.contentView.addChildView(popover);
+        ctx.windows.mainWindow.contentView.addChildView(popover);
         applyPopoverBounds();
         popover.webContents.once('did-finish-load', () => {
             ctx.notify.popoverInit(popover, data);
@@ -211,16 +211,6 @@ export function createViewManager(ctx) {
     function disposeAll() {
         detachSimulator();
     }
-    function logChildViews(_label) {
-        // Debug helper — intentionally a no-op in production. Kept on the
-        // ViewManager interface so call sites and tests stay stable.
-    }
-    function positionSimulator(simWidth) {
-        applySimulatorBounds(simWidth);
-    }
-    function positionSettings() {
-        applySettingsBounds();
-    }
     function resize(simWidth) {
         lastSimWidth = simWidth;
         if (simulatorViewAdded)
@@ -250,10 +240,13 @@ export function createViewManager(ctx) {
         hidePopover,
         repositionAll,
         disposeAll,
-        logChildViews,
-        positionSimulator,
-        positionSettings,
         getSimulatorWebContentsId: () => simulatorWebContentsId,
+        getSimulatorWebContents: () => {
+            if (simulatorWebContentsId == null)
+                return null;
+            const wc = webContents.fromId(simulatorWebContentsId);
+            return wc && !wc.isDestroyed() ? wc : null;
+        },
         getLastSimWidth: () => lastSimWidth,
         isSimulatorAdded: () => simulatorViewAdded,
         hasSimulatorView: () => simulatorView !== null,

package/dist/main/services/window-service.d.ts

@@ -2,9 +2,9 @@ import type { BrowserWindow } from 'electron';
 /**
  * Owns every top-level BrowserWindow the workbench is responsible for.
  *
- * Callers should prefer this service over reading bare `mainWindow` /
- * `workbenchSettingsWindow` fields off `WorkbenchContext` — the latter
- * remain as @deprecated synchronized mirrors during the migration window.
+ * This service is the single source of truth for the main and settings
+ * windows; callers reach them via `ctx.windows.mainWindow` /
+ * `ctx.windows.settingsWindow`.
  */
 export interface WindowService {
     /** The primary devtools window. Created during app bootstrap. */

package/dist/main/services/workbench-context.d.ts

@@ -7,21 +7,18 @@ import { type ViewManager } from './views/view-manager.js';
 import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
 import { sanitizeTemplates } from './projects/templates.js';
-import type { CreateProjectInput, ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
  */
 export interface WorkbenchContext {
-    /** @deprecated use ctx.windows.mainWindow */
-    mainWindow: BrowserWindow;
     adapter: CompilationAdapter;
     /** Absolute path to the preload script loaded into the simulator webview */
     preloadPath: string;
     /** Absolute path to the renderer dist directory */
     rendererDir: string;
-    /** @deprecated use ctx.windows.settingsWindow / setSettingsWindow / closeSettingsWindow */
-    workbenchSettingsWindow: BrowserWindow | null;
     /** Built-in panel IDs to display (default: all) */
     panels: string[];
     /** Custom API namespace names (e.g. ['qd']) passed to the simulator */
@@ -73,7 +70,7 @@ export interface WorkbenchContext {
     customCreateProjectDialog?: (ctx: {
         parentWindow: BrowserWindow;
         templates: ProjectTemplate[];
-    }) => Promise<CreateProjectInput | null>;
+    }) => Promise<CustomCreateProjectDialogResult>;
     /**
      * Trust predicate consulted by `IpcRegistry` for every incoming IPC.
      * Resolves the currently-trusted senders (main renderer + overlays)

package/dist/main/services/workbench-context.js

@@ -20,7 +20,6 @@ export function getDefaultTab(ctx) {
 }
 export function createWorkbenchContext(opts) {
     const ctx = {
-        mainWindow: opts.mainWindow,
         adapter: opts.adapter ?? defaultAdapter,
         preloadPath: opts.preloadPath,
         rendererDir: opts.rendererDir,
@@ -29,10 +28,9 @@ export function createWorkbenchContext(opts) {
         appName: opts.appName ?? 'Dimina DevTools',
         toolbarActions: opts.toolbarActions,
         brandingProvider: opts.brandingProvider,
-        workbenchSettingsWindow: null,
     };
     ctx.registry = new DisposableRegistry();
-    ctx.windows = createWindowService(ctx.mainWindow);
+    ctx.windows = createWindowService(opts.mainWindow);
     ctx.views = createViewManager(ctx);
     ctx.notify = createRendererNotifier(ctx);
     ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();

package/dist/main/services/workspace/workspace-service.js

@@ -1,4 +1,3 @@
-import { webContents } from 'electron';
 import * as repo from '../projects/project-repository.js';
 import { DEFAULT_COMPILE_CONFIG } from '../projects/types.js';
 import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
@@ -39,24 +38,12 @@ export function createWorkspaceService(ctx) {
             setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined);
         }
     }
-    // Delegate to the host-injected (or default) ProjectsProvider on the
-    // context. When the host omits an optional method, we apply a safe
-    // documented default — never silently fall back to `repo.*`, because a
-    // remote provider's project paths are not on the local filesystem.
-    //
-    // The `??` here is a back-compat path for hand-rolled WorkbenchContext
-    // values (used in a couple of legacy tests). createWorkbenchContext
-    // always installs LocalProjectsProvider, so production never enters this
-    // branch.
-    const provider = ctx.projectsProvider ?? {
-        listProjects: () => repo.listProjects(),
-        addProject: (p) => repo.addProject(p),
-        removeProject: (p) => repo.removeProject(p),
-        validateProjectDir: (p) => repo.validateProjectDir(p),
-        updateLastOpened: (p) => repo.updateLastOpened(p),
-        getCompileConfig: (p) => repo.getCompileConfig(p),
-        saveCompileConfig: (p, c) => repo.saveCompileConfig(p, c),
-    };
+    // Delegate to the host-injected (or default LocalProjectsProvider)
+    // ProjectsProvider on the context. When the host omits an optional method,
+    // we apply a safe documented default — never silently fall back to
+    // `repo.*`, because a remote provider's project paths are not on the local
+    // filesystem.
+    const provider = ctx.projectsProvider;
     return {
         listProjects: async () => provider.listProjects(),
         addProject: async (dirPath) => provider.addProject(dirPath),
@@ -129,11 +116,8 @@ export function createWorkspaceService(ctx) {
         getProjectPath: () => currentProjectPath,
         hasActiveSession: () => currentSession !== null,
         async captureThumbnail(projectPath) {
-            const simWcId = ctx.views.getSimulatorWebContentsId();
-            if (!simWcId)
-                return null;
-            const wc = webContents.fromId(simWcId);
-            if (!wc || wc.isDestroyed())
+            const wc = ctx.views.getSimulatorWebContents();
+            if (!wc)
                 return null;
             try {
                 const image = await wc.capturePage();

package/dist/main/utils/theme.d.ts

@@ -1,3 +1,4 @@
+import { type Disposable } from './disposable.js';
 /**
  * Background color that matches the current system color scheme.
  * Pass as `backgroundColor` when creating BrowserWindows to prevent
@@ -7,4 +8,27 @@
  * Light: hsl(0 0% 98%) ≈ #fafafa  (--color-bg)
  */
 export declare function themeBg(): string;
+/**
+ * Install a single process-wide listener that keeps every window's native
+ * `backgroundColor` in sync with the active color scheme.
+ *
+ * A window's `backgroundColor` is otherwise frozen at the value passed to its
+ * constructor: after a theme switch the stale color bleeds through wherever
+ * native chrome and the WebContents meet. On Windows/Linux (in-window menu
+ * bar) it shows as a light hairline between the menu bar and the page; on
+ * macOS (global menu bar) it is latent — only a wrong-color flash on resize.
+ * The defect is platform-agnostic, so the fix is too: one `nativeTheme`
+ * `updated` listener re-syncs every current and future BrowserWindow.
+ *
+ * Known limitation: on Linux the `updated` event does not fire for OS-level
+ * system theme changes (electron/electron#25925) — only for explicit
+ * `nativeTheme.themeSource` assignments. In-app theme switches go through
+ * `applyTheme()` and are unaffected on every platform; the gap is limited to
+ * Linux + `theme: 'system'` + an OS theme change, an upstream Electron
+ * limitation that also leaves the renderer's `prefers-color-scheme` stale.
+ *
+ * Returns a Disposable that detaches the listener. Install it once during
+ * app setup and hand the Disposable to the workbench registry.
+ */
+export declare function installThemeBackgroundSync(): Disposable;
 //# sourceMappingURL=theme.d.ts.map

package/dist/main/utils/theme.js

@@ -1,4 +1,5 @@
-import { nativeTheme } from 'electron';
+import { BrowserWindow, nativeTheme } from 'electron';
+import { toDisposable } from './disposable.js';
 /**
  * Background color that matches the current system color scheme.
  * Pass as `backgroundColor` when creating BrowserWindows to prevent
@@ -10,4 +11,40 @@ import { nativeTheme } from 'electron';
 export function themeBg() {
     return nativeTheme.shouldUseDarkColors ? '#1a1a1a' : '#fafafa';
 }
+/**
+ * Install a single process-wide listener that keeps every window's native
+ * `backgroundColor` in sync with the active color scheme.
+ *
+ * A window's `backgroundColor` is otherwise frozen at the value passed to its
+ * constructor: after a theme switch the stale color bleeds through wherever
+ * native chrome and the WebContents meet. On Windows/Linux (in-window menu
+ * bar) it shows as a light hairline between the menu bar and the page; on
+ * macOS (global menu bar) it is latent — only a wrong-color flash on resize.
+ * The defect is platform-agnostic, so the fix is too: one `nativeTheme`
+ * `updated` listener re-syncs every current and future BrowserWindow.
+ *
+ * Known limitation: on Linux the `updated` event does not fire for OS-level
+ * system theme changes (electron/electron#25925) — only for explicit
+ * `nativeTheme.themeSource` assignments. In-app theme switches go through
+ * `applyTheme()` and are unaffected on every platform; the gap is limited to
+ * Linux + `theme: 'system'` + an OS theme change, an upstream Electron
+ * limitation that also leaves the renderer's `prefers-color-scheme` stale.
+ *
+ * Returns a Disposable that detaches the listener. Install it once during
+ * app setup and hand the Disposable to the workbench registry.
+ */
+export function installThemeBackgroundSync() {
+    const apply = () => {
+        const bg = themeBg();
+        for (const win of BrowserWindow.getAllWindows()) {
+            if (!win.isDestroyed()) {
+                win.setBackgroundColor(bg);
+            }
+        }
+    };
+    nativeTheme.on('updated', apply);
+    return toDisposable(() => {
+        nativeTheme.removeListener('updated', apply);
+    });
+}
 //# sourceMappingURL=theme.js.map

package/dist/preload/index.d.ts

@@ -10,8 +10,11 @@
  * 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 { createAppDataSource } from './instrumentation/app-data.js';
+export type { AppDataSnapshot } from './instrumentation/app-data.js';
+export { createWxmlSource } from './instrumentation/wxml.js';
+export { createMiniappSnapshotHost } from './miniapp-snapshot/host.js';
+export type { MiniappSnapshotHost, MiniappSnapshotSource, SnapshotEnvelope, SnapshotSourceId, } from './miniapp-snapshot/types.js';
 export { installSimulatorBridge } from './runtime/bridge.js';
 export { installCustomApisBridge } from './runtime/custom-apis.js';
 export type { DiminaCustomApisBridge } from './runtime/custom-apis.js';

package/dist/preload/index.js

@@ -10,8 +10,9 @@
  * 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 { createAppDataSource } from './instrumentation/app-data.js';
+export { createWxmlSource } from './instrumentation/wxml.js';
+export { createMiniappSnapshotHost } from './miniapp-snapshot/host.js';
 export { installSimulatorBridge } from './runtime/bridge.js';
 export { installCustomApisBridge } from './runtime/custom-apis.js';
 export { setupApiCompatHook } from './shared/api-compat.js';

package/dist/preload/instrumentation/app-data.d.ts

@@ -1,3 +1,33 @@
-export declare function installAppDataInstrumentation(): () => void;
-export declare function sendAllAppData(): void;
+import type { MiniappSnapshotSource } from '../miniapp-snapshot/types.js';
+/**
+ * The AppData snapshot — the full, cumulative panel state.
+ *
+ * - `bridges` lists every page bridge in chronological (insertion) order, each
+ *   carrying its page route (`pagePath`), so renderer tabs render in a stable
+ *   sequence.
+ * - `entries` maps `bridgeId → (componentPath | moduleId) → setData state`.
+ */
+export interface AppDataSnapshot {
+    bridges: Array<{
+        id: string;
+        pagePath: string | null;
+    }>;
+    entries: Record<string, Record<string, unknown>>;
+}
+/**
+ * The AppData snapshot data source.
+ *
+ * Instruments `window.Worker` (incoming `message` decoding + outgoing
+ * `postMessage` interception) and installs `window.__simulatorHook.appData`,
+ * accumulating per-(bridgeId, moduleId) setData state in an internal cache.
+ * Every cache mutation — an accepted `ub`/`page_*` worker message, or a
+ * `pageUnload` evicting a bridge — calls `emit()` so the `miniappSnapshot`
+ * host republishes the full snapshot. The source itself never touches IPC:
+ * the host owns push, pull and the install-time publish.
+ *
+ * It keeps the `__simulatorData.getAppdata()` automation surface working by
+ * mirroring the flat cache into the simulator bridge via `setAppDataSnapshot`
+ * / `clearAppDataSnapshot`.
+ */
+export declare function createAppDataSource(): MiniappSnapshotSource<AppDataSnapshot>;
 //# sourceMappingURL=app-data.d.ts.map