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

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

@@ -16,9 +16,18 @@
  *     events stop flowing until they close it.
  */
 import { app, webContents as wcStatic } from 'electron';
+import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 import { SimulatorElementChannel, SimulatorStorageChannel, } from '../../../shared/ipc-channels.js';
-import { DisposableRegistry } from '../../utils/disposable.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
+import { decodeStorageValue, encodeStorageValue, serviceStorage } from './service-storage-ops.js';
+/** Async wx storage API names routed through the unified service-window store. */
+export const STORAGE_API_NAMES = new Set([
+    'setStorage',
+    'getStorage',
+    'removeStorage',
+    'clearStorage',
+    'getStorageInfo',
+]);
 function isSimulatorWebview(wc) {
     if (wc.isDestroyed())
         return false;
@@ -39,6 +48,15 @@ function safeOff(target, event, fn) {
 export function setupSimulatorStorage(host, options) {
     const registry = new DisposableRegistry();
     const getActiveAppId = options.getActiveAppId;
+    // Native-host: the mini-app's storage lives on the service-host window's
+    // file:// origin (sync-impls + the unified async path both write there), not
+    // the simulator <webview>'s http:// origin the CDP path attaches to. Resolve
+    // the service window fresh each call (the pre-warm pool can swap it on respawn).
+    function nativeServiceWc() {
+        if (!options.bridge?.isNativeHost())
+            return null;
+        return options.bridge.getServiceWc(getActiveAppId() ?? undefined);
+    }
     let attachedWc = null;
     let attachDisposables = null;
     /**
@@ -107,8 +125,23 @@ export function setupSimulatorStorage(host, options) {
                         void ad.disposeAll().catch(() => { });
                 }
             };
-            wc.once('destroyed', onDestroyed);
-            attach.add(() => safeOff(wc, 'destroyed', onDestroyed));
+            if (options.connections) {
+                // Route through the connection layer: own() disposes onDestroyed
+                // deterministically on wc destroy / connection reset, and the returned
+                // Disposable lets us release it early when this attach segment tears
+                // down (detach / re-attach).
+                const owned = options.connections.acquire(wc).own(onDestroyed);
+                attach.add(() => owned.dispose());
+            }
+            else {
+                try {
+                    wc.once('destroyed', onDestroyed);
+                }
+                catch {
+                    // fake-wc safety (unit tests pass a wc without a real emitter)
+                }
+                attach.add(() => safeOff(wc, 'destroyed', onDestroyed));
+            }
             attachedWc = wc;
         }
         catch (e) {
@@ -257,6 +290,17 @@ export function setupSimulatorStorage(host, options) {
         host.send(SimulatorStorageChannel.Event, evt);
     }
     async function setItem(key, value) {
+        const nativeWc = nativeServiceWc();
+        if (nativeWc) {
+            try {
+                await serviceStorage(nativeWc).writeOne(key, value);
+                pushSyntheticEvent({ type: 'added', key, newValue: value });
+                return { ok: true };
+            }
+            catch (e) {
+                return { ok: false, error: e.message };
+            }
+        }
         return withStorageWrite(async ({ wc, storageId }) => {
             await wc.debugger.sendCommand('DOMStorage.setDOMStorageItem', { storageId, key, value });
             pushSyntheticEvent({ type: 'added', key, newValue: value });
@@ -264,6 +308,17 @@ export function setupSimulatorStorage(host, options) {
         });
     }
     async function removeItem(key) {
+        const nativeWc = nativeServiceWc();
+        if (nativeWc) {
+            try {
+                await serviceStorage(nativeWc).removeOne(key);
+                pushSyntheticEvent({ type: 'removed', key });
+                return { ok: true };
+            }
+            catch (e) {
+                return { ok: false, error: e.message };
+            }
+        }
         return withStorageWrite(async ({ wc, storageId }) => {
             await wc.debugger.sendCommand('DOMStorage.removeDOMStorageItem', { storageId, key });
             pushSyntheticEvent({ type: 'removed', key });
@@ -275,6 +330,23 @@ export function setupSimulatorStorage(host, options) {
     // 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() {
+        const nativeWc = nativeServiceWc();
+        if (nativeWc) {
+            try {
+                const prefix = activePrefix();
+                const ss = serviceStorage(nativeWc);
+                if (prefix)
+                    await ss.clearPrefix(prefix);
+                else
+                    await ss.clearAll();
+                if (!host.isDestroyed())
+                    host.send(SimulatorStorageChannel.Event, { type: 'cleared' });
+                return { ok: true };
+            }
+            catch (e) {
+                return { ok: false, error: e.message };
+            }
+        }
         return withStorageWrite(async ({ wc, storageId }) => {
             const prefix = activePrefix();
             if (!prefix) {
@@ -296,12 +368,33 @@ export function setupSimulatorStorage(host, options) {
     // state in the shared simulator partition. The renderer guards this with a
     // confirm dialog; we don't second-guess here.
     async function clearAll() {
+        const nativeWc = nativeServiceWc();
+        if (nativeWc) {
+            try {
+                await serviceStorage(nativeWc).clearAll();
+                if (!host.isDestroyed())
+                    host.send(SimulatorStorageChannel.Event, { type: 'cleared' });
+                return { ok: true };
+            }
+            catch (e) {
+                return { ok: false, error: e.message };
+            }
+        }
         return withStorageWrite(async ({ wc, storageId }) => {
             await wc.debugger.sendCommand('DOMStorage.clear', { storageId });
             return { ok: true };
         });
     }
     async function getSnapshot() {
+        const nativeWc = nativeServiceWc();
+        if (nativeWc) {
+            const prefix = activePrefix();
+            if (!prefix)
+                return [];
+            const entries = await serviceStorage(nativeWc).readAll(prefix);
+            // Keys returned with the `${appId}_` prefix intact (same as the CDP path).
+            return entries.map(([key, value]) => ({ key, value }));
+        }
         return withStorageRead([], async ({ wc, storageId }) => {
             const result = (await wc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
                 storageId,
@@ -337,10 +430,24 @@ export function setupSimulatorStorage(host, options) {
         };
         wc.on('did-finish-load', onFinishLoad);
         sub.add(() => safeOff(wc, 'did-finish-load', onFinishLoad));
-        wc.once('destroyed', () => {
+        const onWcDestroyed = () => {
             void sub.disposeAll().catch(() => { });
             wcSubs.delete(wc);
-        });
+        };
+        if (options.connections) {
+            // Per-wc cleanup (this wc's did-finish-load sub + wcSubs entry). Route
+            // through the connection layer so it fires deterministically on wc
+            // destroy / reset rather than the bespoke 'destroyed' hook.
+            options.connections.acquire(wc).own(onWcDestroyed);
+        }
+        else {
+            try {
+                wc.once('destroyed', onWcDestroyed);
+            }
+            catch {
+                // fake-wc safety (unit tests pass a wc without a real emitter)
+            }
+        }
     };
     app.on('web-contents-created', onWcCreated);
     registry.add(() => {
@@ -353,6 +460,49 @@ export function setupSimulatorStorage(host, options) {
             await sub.disposeAll().catch(() => { });
         }
     });
+    // Element inspection. Default path delegates to the simulator iframe's
+    // `__simulatorData`. Native-host path targets the active render-host
+    // <webview> guest via the render inspector (the page DOM lives there, not in
+    // the simulator iframe). Looked up fresh each call so a DevTools-induced CDP
+    // detach (default path) or a render-guest swap (native path) is tolerated.
+    async function inspectElement(sid) {
+        if (!sid)
+            return null;
+        if (options.bridge?.isNativeHost() && options.renderInspector) {
+            const wc = options.bridge.getActiveRenderWc(getActiveAppId() ?? undefined);
+            if (!wc)
+                return null;
+            return options.renderInspector.highlight(wc, sid);
+        }
+        const sim = findSimulatorWebContents();
+        if (!sim)
+            return null;
+        try {
+            const result = (await sim.executeJavaScript(`window.__simulatorData && window.__simulatorData.highlightElement ? window.__simulatorData.highlightElement(${JSON.stringify(sid)}) : null`));
+            return result ?? null;
+        }
+        catch (e) {
+            console.warn('[simulator-element] inspect failed:', e.message);
+            return null;
+        }
+    }
+    async function clearElementInspection() {
+        if (options.bridge?.isNativeHost() && options.renderInspector) {
+            const wc = options.bridge.getActiveRenderWc(getActiveAppId() ?? undefined);
+            if (wc)
+                await options.renderInspector.unhighlight(wc);
+            return;
+        }
+        const sim = findSimulatorWebContents();
+        if (!sim)
+            return;
+        try {
+            await sim.executeJavaScript('window.__simulatorData && window.__simulatorData.unhighlightElement && window.__simulatorData.unhighlightElement()');
+        }
+        catch {
+            // best-effort
+        }
+    }
     // IPC handlers — gated by the workbench SenderPolicy when provided so this
     // module routes through the same C-stage sender white-list as every other
     // workbench-built-in (main-window renderer + overlay views only). Without
@@ -370,7 +520,60 @@ export function setupSimulatorStorage(host, options) {
     registry.add(ipc);
     // Detach active CDP session last
     registry.add(() => detachFromSim());
-    return registry;
+    // ── Runtime async-storage unification (native-host) ───────────────────────
+    // bridge-router routes async wx.setStorage/etc. here so they hit the SAME
+    // service-host file:// store as the sync APIs (no more split origin). After a
+    // write we push a synthetic panel event so the Storage panel stays live on
+    // in-app writes (executeJavaScript writes don't emit CDP DOMStorage events).
+    async function runtimeInvoke(appId, name, params) {
+        const wc = options.bridge?.getServiceWc(appId);
+        if (!wc)
+            throw new Error('service-host window unavailable');
+        const ss = serviceStorage(wc);
+        const prefix = `${appId}_`;
+        const key = typeof params.key === 'string' ? params.key : '';
+        const fullKey = prefix + key;
+        switch (name) {
+            case 'setStorage': {
+                const value = encodeStorageValue(params.data);
+                await ss.writeOne(fullKey, value);
+                pushSyntheticEvent({ type: 'added', key: fullKey, newValue: value });
+                return { errMsg: 'setStorage:ok' };
+            }
+            case 'getStorage': {
+                const raw = await ss.readOne(fullKey);
+                if (raw === null)
+                    throw new Error('getStorage:fail data not found');
+                return { data: decodeStorageValue(raw), errMsg: 'getStorage:ok' };
+            }
+            case 'removeStorage': {
+                await ss.removeOne(fullKey);
+                pushSyntheticEvent({ type: 'removed', key: fullKey });
+                return { errMsg: 'removeStorage:ok' };
+            }
+            case 'clearStorage': {
+                await ss.clearPrefix(prefix);
+                if (appId === getActiveAppId() && !host.isDestroyed()) {
+                    host.send(SimulatorStorageChannel.Event, { type: 'cleared' });
+                }
+                return { errMsg: 'clearStorage:ok' };
+            }
+            case 'getStorageInfo': {
+                const entries = await ss.readAll(prefix);
+                const keys = entries.map(([k]) => k.slice(prefix.length));
+                let currentSize = 0;
+                for (const [, v] of entries)
+                    currentSize += v ? v.length * 2 : 0;
+                return { keys, currentSize, limitSize: 10 * 1024 * 1024, errMsg: 'getStorageInfo:ok' };
+            }
+            default:
+                throw new Error(`unsupported storage api ${name}`);
+        }
+    }
+    const storageApi = options.bridge?.isNativeHost()
+        ? { invoke: runtimeInvoke }
+        : null;
+    return { dispose: () => registry.dispose(), storageApi };
 }
 // Element inspection delegates to the simulator preload's __simulatorData
 // bridge via executeJavaScript. Looked up independently from `attachedWc` so
@@ -383,30 +586,4 @@ function findSimulatorWebContents() {
     }
     return null;
 }
-async function inspectElement(sid) {
-    if (!sid)
-        return null;
-    const sim = findSimulatorWebContents();
-    if (!sim)
-        return null;
-    try {
-        const result = (await sim.executeJavaScript(`window.__simulatorData && window.__simulatorData.highlightElement ? window.__simulatorData.highlightElement(${JSON.stringify(sid)}) : null`));
-        return result ?? null;
-    }
-    catch (e) {
-        console.warn('[simulator-element] inspect failed:', e.message);
-        return null;
-    }
-}
-async function clearElementInspection() {
-    const sim = findSimulatorWebContents();
-    if (!sim)
-        return;
-    try {
-        await sim.executeJavaScript('window.__simulatorData && window.__simulatorData.unhighlightElement && window.__simulatorData.unhighlightElement()');
-    }
-    catch {
-        // best-effort
-    }
-}
 //# sourceMappingURL=index.js.map

package/dist/main/services/simulator-storage/service-storage-ops.d.ts

@@ -0,0 +1,40 @@
+/**
+ * service-storage-ops — localStorage primitives executed INSIDE the service-host
+ * window (`wc`) via `executeJavaScript`, plus the wx-storage value encode/decode
+ * pair.
+ *
+ * Under native-host the mini-app's storage lives on the service-host window's
+ * `file://` origin (sync APIs write there via sync-impls/storage.ts, and the
+ * unified async path routes there too). The Storage panel + the async-storage
+ * runtime both read/write through here so there is exactly ONE store.
+ *
+ * The key/value scheme stays byte-compatible with
+ * `src/service-host/sync-impls/storage.ts` (the authoritative wx storage impl):
+ *   - key   = `${appId}_${key}`
+ *   - value = `typeof data === 'object' ? JSON.stringify(data) : String(data)`
+ *   - scoped clear removes every key whose name startsWith `${appId}_`
+ *
+ * Args are embedded via JSON.stringify so special characters can't break out of
+ * the injected code. Reads tolerate failure (→ []/null); writes propagate so the
+ * caller can fail the wx callback / surface the panel error.
+ */
+import type { WebContents } from 'electron';
+/** Encode a wx storage value to its localStorage string form. Matches sync-impls/storage.ts. */
+export declare function encodeStorageValue(data: unknown): string;
+/** Decode a localStorage string back to a value (JSON.parse, falling back to the raw string). */
+export declare function decodeStorageValue(raw: string): unknown;
+export interface ServiceStorage {
+    /** All [fullKey, value] entries whose key startsWith `prefix`. */
+    readAll(prefix: string): Promise<Array<[string, string]>>;
+    /** Raw value for a full (already-prefixed) key, or null if absent. */
+    readOne(fullKey: string): Promise<string | null>;
+    writeOne(fullKey: string, value: string): Promise<void>;
+    removeOne(fullKey: string): Promise<void>;
+    /** Remove every key whose name startsWith `prefix`. */
+    clearPrefix(prefix: string): Promise<void>;
+    /** Origin-wide localStorage.clear(). */
+    clearAll(): Promise<void>;
+}
+/** localStorage ops executed inside `wc` (the service-host window) via executeJavaScript. */
+export declare function serviceStorage(wc: WebContents): ServiceStorage;
+//# sourceMappingURL=service-storage-ops.d.ts.map

package/dist/main/services/simulator-storage/service-storage-ops.js

@@ -0,0 +1,67 @@
+/** Encode a wx storage value to its localStorage string form. Matches sync-impls/storage.ts. */
+export function encodeStorageValue(data) {
+    return typeof data === 'object' ? JSON.stringify(data) : String(data);
+}
+/** Decode a localStorage string back to a value (JSON.parse, falling back to the raw string). */
+export function decodeStorageValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** localStorage ops executed inside `wc` (the service-host window) via executeJavaScript. */
+export function serviceStorage(wc) {
+    return {
+        async readAll(prefix) {
+            const code = `(() => {
+        const out = []
+        const p = ${JSON.stringify(prefix)}
+        for (let i = 0; i < localStorage.length; i++) {
+          const k = localStorage.key(i)
+          if (k && k.startsWith(p)) out.push([k, localStorage.getItem(k)])
+        }
+        return out
+      })()`;
+            try {
+                const result = await wc.executeJavaScript(code);
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async readOne(fullKey) {
+            try {
+                const result = await wc.executeJavaScript(`localStorage.getItem(${JSON.stringify(fullKey)})`);
+                return result === null || result === undefined ? null : String(result);
+            }
+            catch {
+                return null;
+            }
+        },
+        async writeOne(fullKey, value) {
+            await wc.executeJavaScript(`localStorage.setItem(${JSON.stringify(fullKey)}, ${JSON.stringify(value)})`);
+        },
+        async removeOne(fullKey) {
+            await wc.executeJavaScript(`localStorage.removeItem(${JSON.stringify(fullKey)})`);
+        },
+        async clearPrefix(prefix) {
+            const code = `(() => {
+        const p = ${JSON.stringify(prefix)}
+        const doomed = []
+        for (let i = 0; i < localStorage.length; i++) {
+          const k = localStorage.key(i)
+          if (k && k.startsWith(p)) doomed.push(k)
+        }
+        doomed.forEach((k) => localStorage.removeItem(k))
+      })()`;
+            await wc.executeJavaScript(code);
+        },
+        async clearAll() {
+            await wc.executeJavaScript('localStorage.clear()');
+        },
+    };
+}
+//# sourceMappingURL=service-storage-ops.js.map

package/dist/main/services/simulator-temp-files/index.d.ts

@@ -28,6 +28,6 @@
  * size cap), simplified for a dev-tools session scope.
  */
 import type { Session } from 'electron';
-import { type Disposable } from '../../utils/disposable.js';
+import { type Disposable } from '@dimina-kit/electron-deck/main';
 export declare function setupSimulatorTempFiles(simSession: Session): Disposable;
 //# sourceMappingURL=index.d.ts.map

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

@@ -28,9 +28,10 @@
  * size cap), simplified for a dev-tools session scope.
  */
 import { IpcRegistry } from '../../utils/ipc-registry.js';
-import { toDisposable } from '../../utils/disposable.js';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
 import { registerTempFile, revokeTempFile, revokeAllTempFiles } from './store.js';
 import { handleDifileRequest } from './request-handler.js';
+import { registerMiniappSessionConfigurator } from '../views/miniapp-partition.js';
 import { handleFsMkdir, handleFsRead, handleFsReaddir, handleFsStat, handleFsUnlink, handleFsWrite, } from './fs-channels.js';
 /** Upper bound for in-memory entries; oldest insertion is evicted (FIFO). */
 const MAX_STORE_ENTRIES = 200;
@@ -63,7 +64,12 @@ export function setupSimulatorTempFiles(simSession) {
             for (const fn of list)
                 fn();
     }
-    const simulatorOnlyPolicy = sender => !sender.isDestroyed() && sender.session === simSession;
+    // The protocol handler + IPC channels are shared across every per-project
+    // miniapp partition session (each project's render/service runs the same
+    // difile:// + temp-file FSM). The base session is always trusted; additional
+    // per-project partition sessions register themselves via `installOnSession`.
+    const trustedSessions = new Set([simSession]);
+    const simulatorOnlyPolicy = sender => !sender.isDestroyed() && trustedSessions.has(sender.session);
     const registry = new IpcRegistry(simulatorOnlyPolicy);
     registry.on('simulator:temp-file:write', (_event, payload) => {
         if (disposed)
@@ -84,15 +90,7 @@ export function setupSimulatorTempFiles(simSession) {
             return;
         revokeAllTempFiles(store);
     });
-    // Idempotent: a stale handler from a prior setup (e.g. fast app
-    // re-init in tests) is replaced rather than throwing.
-    try {
-        simSession.protocol.unhandle('difile');
-    }
-    catch {
-        // Not previously registered — fine.
-    }
-    simSession.protocol.handle('difile', async (req) => {
+    const difileHandler = async (req) => {
         const url = req.url;
         // Forward any HTTP headers Electron parsed (Range / If-None-Match)
         // to the pure dispatcher so it can do its own conditional / range
@@ -135,7 +133,28 @@ export function setupSimulatorTempFiles(simSession) {
             res = await handleDifileRequest(ctx, { url, headers });
         }
         return res;
-    });
+    };
+    // Install the difile:// protocol handler on a session. Idempotent per
+    // session: a stale handler from a prior setup (e.g. fast app re-init in
+    // tests) is replaced rather than throwing. Trusts that session's senders for
+    // the temp-file / fs IPC channels.
+    const installedSessions = new Set();
+    function installOnSession(sess) {
+        trustedSessions.add(sess);
+        if (installedSessions.has(sess))
+            return;
+        installedSessions.add(sess);
+        try {
+            sess.protocol.unhandle('difile');
+        }
+        catch {
+            // Not previously registered — fine.
+        }
+        sess.protocol.handle('difile', difileHandler);
+    }
+    installOnSession(simSession);
+    // Apply to every per-project miniapp partition session (current + future).
+    const unregisterConfigurator = registerMiniappSessionConfigurator((sess) => installOnSession(sess));
     // Phase 1 (P1-7): renderer FSM → main fs operations bridge. The same
     // simulator-only sender policy applies — registry instance is shared.
     registry.handle('simulator:fs:read', (_event, payload) => handleFsRead(payload));
@@ -146,13 +165,16 @@ export function setupSimulatorTempFiles(simSession) {
     registry.handle('simulator:fs:mkdir', (_event, payload) => handleFsMkdir(payload));
     return toDisposable(async () => {
         disposed = true;
+        unregisterConfigurator();
         drainAllWaiters();
         store.clear();
-        try {
-            simSession.protocol.unhandle('difile');
-        }
-        catch {
-            // May already have been unhandled by app shutdown.
+        for (const sess of installedSessions) {
+            try {
+                sess.protocol.unhandle('difile');
+            }
+            catch {
+                // May already have been unhandled by app shutdown.
+            }
         }
         await registry.dispose();
     });

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

@@ -0,0 +1,29 @@
+/**
+ * Native-host WXML panel service.
+ *
+ * Mirrors simulator-storage's main→renderer contract so the renderer WXML panel
+ * needs no per-mode branching of its own data shape:
+ *   - PULL: answers `SimulatorWxmlChannel.GetSnapshot` by reading the active
+ *     render-host guest's WXML tree via the injected RenderInspector.
+ *   - PUSH: on bridge render-side activity (domReady / active-page change),
+ *     re-reads the tree and pushes `SimulatorWxmlChannel.Event` to the renderer
+ *     host — keeping the panel reactive without polling.
+ *
+ * Only meaningful under native-host (the default dimina-fe path sources WXML
+ * from the simulator guest's miniappSnapshot transport); app.ts gates the call
+ * on `ctx.bridge.isNativeHost()`.
+ */
+import type { WebContents } from 'electron';
+import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../../utils/ipc-registry.js';
+import type { RenderInspector } from '../render-inspect/index.js';
+export interface SimulatorWxmlOptions {
+    bridge: BridgeRouterHandle;
+    inspector: RenderInspector;
+    getActiveAppId: () => string | null;
+    /** Sender gate applied to the WXML IPC handler; omitted in unit tests. */
+    senderPolicy?: SenderPolicy;
+}
+export declare function setupSimulatorWxml(host: WebContents, options: SimulatorWxmlOptions): Disposable;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,28 @@
+import { SimulatorWxmlChannel } from '../../../shared/ipc-channels.js';
+import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+import { IpcRegistry } from '../../utils/ipc-registry.js';
+export function setupSimulatorWxml(host, options) {
+    const { bridge, inspector, getActiveAppId } = options;
+    const registry = new DisposableRegistry();
+    /** Read the WXML tree of the visible page of the active app, or null. */
+    async function pull() {
+        const wc = bridge.getActiveRenderWc(getActiveAppId() ?? undefined);
+        if (!wc)
+            return null;
+        return inspector.getWxml(wc);
+    }
+    const ipc = new IpcRegistry(options.senderPolicy);
+    ipc.handle(SimulatorWxmlChannel.GetSnapshot, () => pull());
+    registry.add(ipc);
+    // Re-read + push when a page's DOM mounts or the visible page changes.
+    const unsubscribe = bridge.onRenderEvent(() => {
+        void pull().then((tree) => {
+            if (host.isDestroyed())
+                return;
+            host.send(SimulatorWxmlChannel.Event, tree);
+        });
+    });
+    registry.add(unsubscribe);
+    return registry;
+}
+//# sourceMappingURL=index.js.map

package/dist/main/services/toolbar/toolbar-store.d.ts

@@ -4,8 +4,8 @@ import type { ToolbarAction, ToolbarActionInput } from '../../../shared/types.js
  *
  * The toolbar is modelled as "one table the host recomputes from its current
  * state": `set()` replaces the whole table atomically. The non-serialisable
- * `handler` is kept main-process side; `list()` projects display metadata for
- * the IPC boundary, and `getHandler()` resolves a handler by id.
+ * `handler` is kept main-process side; `list()` projects to `{id,label}[]`
+ * for the IPC boundary, and `getHandler()` resolves a handler by id.
  */
 export interface ToolbarStore {
     /**
@@ -14,7 +14,7 @@ export interface ToolbarStore {
      * a rejected batch leaves the previous table intact.
      */
     set(actions: ToolbarActionInput[]): void;
-    /** Project the current table to serialisable display metadata — no `handler` leaks out. */
+    /** Project the current table to `{id,label}[]` — no `handler` leaks out. */
     list(): ToolbarAction[];
     /** Resolve the handler stored under `id`, or `undefined` if unknown. */
     getHandler(id: string): (() => void | Promise<void>) | undefined;

package/dist/main/services/toolbar/toolbar-store.js

@@ -1,20 +1,3 @@
-function toPublicAction(action) {
-    const projected = {
-        id: action.id,
-        label: action.label,
-    };
-    if (action.kind)
-        projected.kind = action.kind;
-    if (action.placement)
-        projected.placement = action.placement;
-    if (action.icon)
-        projected.icon = action.icon;
-    if (action.displayInitial)
-        projected.displayInitial = action.displayInitial;
-    if (action.avatarUrl)
-        projected.avatarUrl = action.avatarUrl;
-    return projected;
-}
 export function createToolbarStore() {
     let actions = [];
     return {
@@ -30,7 +13,7 @@ export function createToolbarStore() {
             actions = next.slice();
         },
         list() {
-            return actions.map(toPublicAction);
+            return actions.map(({ id, label }) => ({ id, label }));
         },
         getHandler(id) {
             return actions.find((a) => a.id === id)?.handler;