@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/services/simulator/ui-extensions.js

@@ -0,0 +1,176 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const EXTENSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+ * The rules a registration has to satisfy on its own, with no window and no
+ * renderer involved: the id is a lookup key on both sides of the bridge, and
+ * the script is read straight from disk with no base to resolve against. They
+ * hold wherever a registration is accepted, so whoever accepts one first is
+ * where a host learns it is unusable.
+ */
+export function assertSimulatorUiExtensionShape(registration) {
+    if (!EXTENSION_ID_RE.test(registration.id)) {
+        throw new Error(`Invalid simulator UI extension id: "${registration.id}"`);
+    }
+    if (!isAbsolute(registration.rendererScriptPath)) {
+        throw new Error('Simulator UI extension rendererScriptPath must be absolute');
+    }
+}
+export function createSimulatorUiExtensionRegistry(options = {}) {
+    const loadSource = options.loadSource ?? (scriptPath => readFile(scriptPath, 'utf8'));
+    const entries = new Map();
+    let active = null;
+    function assertRegistration(registration) {
+        assertSimulatorUiExtensionShape(registration);
+        if (entries.has(registration.id)) {
+            throw new Error(`Simulator UI extension "${registration.id}" is already registered`);
+        }
+    }
+    function activeExpression(method, args) {
+        return `globalThis.__diminaSimulatorUi.${method}(${args.map(arg => JSON.stringify(arg)).join(',')})`;
+    }
+    async function install(entry, target) {
+        const { id, rendererScriptPath } = entry.registration;
+        if (target.loaded.has(id))
+            return;
+        const pending = target.loading.get(id);
+        if (pending)
+            return await pending;
+        const generation = target.generation;
+        const task = (async () => {
+            // Read once per simulator document generation so downstream watch builds
+            // become visible after a hard reload without restarting the workbench.
+            const source = await loadSource(rendererScriptPath);
+            if (entries.get(id) !== entry
+                ||
+                    active !== target
+                || target.webContents.isDestroyed()
+                || !target.ready
+                || target.generation !== generation) {
+                throw new Error('Simulator UI extension target is no longer available');
+            }
+            const sourceUrl = pathToFileURL(rendererScriptPath).href;
+            const wrapped = `(()=>{\n${source}\n;return undefined\n})()\n//# sourceURL=${sourceUrl}`;
+            await target.webContents.executeJavaScript(wrapped, true);
+            if (entries.get(id) !== entry
+                ||
+                    active !== target
+                || target.webContents.isDestroyed()
+                || !target.ready
+                || target.generation !== generation) {
+                throw new Error('Simulator UI extension target was destroyed during installation');
+            }
+            const registered = await target.webContents.executeJavaScript(`Boolean(globalThis.__diminaSimulatorUi?.has(${JSON.stringify(id)}))`, true);
+            if (!registered) {
+                throw new Error(`Simulator UI extension "${id}" did not register its renderer implementation`);
+            }
+            target.loaded.add(id);
+        })().finally(() => {
+            if (target.loading.get(id) === task)
+                target.loading.delete(id);
+        });
+        target.loading.set(id, task);
+        return await task;
+    }
+    async function installAll(target) {
+        for (const entry of entries.values()) {
+            try {
+                await install(entry, target);
+            }
+            catch (error) {
+                console.warn(`[simulator-ui] failed to install "${entry.registration.id}":`, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    function uninstall(id, target = active) {
+        if (!target)
+            return;
+        target.loaded.delete(id);
+        target.loading.delete(id);
+        if (!target.ready || target.webContents.isDestroyed())
+            return;
+        void target.webContents.executeJavaScript(`globalThis.__diminaSimulatorUi?.unregister(${JSON.stringify(id)})`, true).catch(() => { });
+    }
+    function detach(webContents) {
+        const target = active;
+        if (!target || (webContents && target.webContents !== webContents))
+            return;
+        active = null;
+        if (!target.webContents.isDestroyed()) {
+            target.webContents.removeListener('did-finish-load', target.onLoaded);
+        }
+        target.loaded.clear();
+        target.loading.clear();
+    }
+    function attach(webContents) {
+        detach();
+        const target = {
+            webContents,
+            ready: false,
+            generation: 0,
+            loaded: new Set(),
+            loading: new Map(),
+            onLoaded: () => { },
+        };
+        target.onLoaded = () => {
+            if (active !== target || webContents.isDestroyed())
+                return;
+            target.ready = true;
+            target.generation += 1;
+            target.loaded.clear();
+            target.loading.clear();
+            void installAll(target);
+        };
+        active = target;
+        webContents.on('did-finish-load', target.onLoaded);
+    }
+    function register(registration) {
+        assertRegistration(registration);
+        const stableRegistration = { ...registration };
+        const entry = {
+            registration: stableRegistration,
+        };
+        entries.set(stableRegistration.id, entry);
+        const target = active;
+        if (target?.ready) {
+            void install(entry, target).catch((error) => {
+                console.warn(`[simulator-ui] failed to install "${stableRegistration.id}":`, error instanceof Error ? error.message : String(error));
+            });
+        }
+        let disposed = false;
+        return {
+            dispose() {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (entries.get(stableRegistration.id) !== entry)
+                    return;
+                entries.delete(stableRegistration.id);
+                uninstall(stableRegistration.id);
+            },
+            async invoke(method, params) {
+                if (disposed || entries.get(stableRegistration.id) !== entry) {
+                    throw new Error(`Simulator UI extension "${stableRegistration.id}" is disposed`);
+                }
+                const current = active;
+                if (!current || current.webContents.isDestroyed() || !current.ready) {
+                    throw new Error('Dimina simulator UI is not ready');
+                }
+                await install(entry, current);
+                if (active !== current || current.webContents.isDestroyed()) {
+                    throw new Error('Dimina simulator UI was replaced during invocation');
+                }
+                return await current.webContents.executeJavaScript(activeExpression('invoke', [stableRegistration.id, method, params ?? null]), true);
+            },
+        };
+    }
+    function clear() {
+        for (const id of entries.keys())
+            uninstall(id);
+        entries.clear();
+        detach();
+    }
+    return { register, attach, detach, clear };
+}
+//# sourceMappingURL=ui-extensions.js.map

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

@@ -30,6 +30,12 @@ export interface SimulatorAppDataService extends AppDataTap, Disposable {
 export interface SimulatorAppDataOptions {
     getActiveAppId: () => string | null;
     senderPolicy?: SenderPolicy;
+    /** Resolves the service-host WebContents owning a page bridge — the SetData
+     * write-back target. Absent (host without a service bridge) → edits are
+     * rejected with `false`. */
+    bridge?: {
+        getServiceWcForBridge: (bridgeId: string) => WebContents | null;
+    };
 }
 export declare function setupSimulatorAppData(host: WebContents, options: SimulatorAppDataOptions): SimulatorAppDataService;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,5 @@
-import { SimulatorAppDataChannel } from '../../../shared/ipc-channels.js';
-import { AppDataAccumulator, decodeWorkerMessage, decodedToInput, } from '../../../shared/appdata-accumulator.js';
+import { ServiceHostChannel, SimulatorAppDataChannel } from '../../../shared/ipc-channels.js';
+import { AppDataAccumulator, decodeWorkerMessage, decodedToInput, } from '@dimina-kit/inspect';
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
 const EMPTY_SNAPSHOT = { bridges: [], entries: {} };
@@ -54,6 +54,25 @@ export function setupSimulatorAppData(host, options) {
             return EMPTY_SNAPSHOT;
         return accumulators.get(appId)?.snapshot() ?? EMPTY_SNAPSHOT;
     });
+    /** A plain, non-empty `{key: value}` patch — the only shape page.setData accepts. */
+    function isValidSetDataPatch(data) {
+        return !!data && typeof data === 'object' && !Array.isArray(data)
+            && Object.keys(data).length > 0;
+    }
+    ipc.handle(SimulatorAppDataChannel.SetData, (_event, payload) => {
+        const p = payload;
+        if (!p || typeof p !== 'object')
+            return false;
+        if (typeof p.bridgeId !== 'string' || p.bridgeId.length === 0)
+            return false;
+        if (!isValidSetDataPatch(p.data))
+            return false;
+        const wc = options.bridge?.getServiceWcForBridge(p.bridgeId);
+        if (!wc || wc.isDestroyed())
+            return false;
+        wc.send(ServiceHostChannel.AppDataSetData, { bridgeId: p.bridgeId, data: p.data });
+        return true;
+    });
     // disposeAll runs LIFO; add the IPC registry LAST so it is torn down first —
     // its removeHandler then runs synchronously (before the first `await` yields),
     // which callers that `dispose()` without awaiting rely on.

package/dist/main/services/simulator-current-page/index.d.ts

@@ -6,9 +6,11 @@
  * page a nested render-host `<webview>`), not a renderer `<webview>` the main
  * window can observe — so in-app navigation (navigateTo / switchTab / back)
  * never reaches the renderer's `<webview>` did-navigate events. This service
- * taps the bridge's active-page signal and pushes the new route to the
- * main-window renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in
- * sync without polling.
+ * taps the bridge's active-page signal and pushes the route — page path plus
+ * its launch query, so the simulator's page-path bar shows params just like
+ * WeChat DevTools and a recompile can restore them — to the main-window
+ * renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in sync
+ * without polling.
  *
  * Inert on the default dimina-fe path (which derives the current page from the
  * simulator `<webview>`'s navigation events); app.ts gates the call on

package/dist/main/services/simulator-current-page/index.js

@@ -1,4 +1,5 @@
 import { SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { encodePageSpec } from '../../../shared/simulator-route.js';
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 export function setupSimulatorCurrentPage(host, options) {
     const registry = new DisposableRegistry();
@@ -11,7 +12,13 @@ export function setupSimulatorCurrentPage(host, options) {
             return;
         if (host.isDestroyed())
             return;
-        host.send(SimulatorChannel.CurrentPage, ev.pagePath);
+        // Bridge queries are `Record<string, unknown>` (they may hold numbers from
+        // the URL); the route format wants strings. encodePageSpec re-encodes with
+        // `?k=v&…` so the renderer can decode it back into { pagePath, query }.
+        const query = {};
+        for (const [k, v] of Object.entries(ev.query ?? {}))
+            query[k] = String(v);
+        host.send(SimulatorChannel.CurrentPage, encodePageSpec({ pagePath: ev.pagePath, query }));
     });
     registry.add(off);
     return registry;

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

@@ -2,23 +2,30 @@
  * SimulatorStorageWatcher
  *
  * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
- * and forwards `DOMStorage.*` events to the renderer host.
+ * and forwards `DOMStorage.*` events to the renderer host. The SAME simulator
+ * wc's debugger session is independently captured by network-forward
+ * (Network.* events); both acquire a lease from the shared `CdpSessionBroker`
+ * (see cdp-session/index.ts) rather than each attaching/detaching directly —
+ * releasing our own lease never forces a physical detach that would kill the
+ * other's capture.
  *
  * Trade-offs vs a preload-side localStorage.setItem hook:
  *   + Uses standard browser protocol; no preload injection
  *   + Captures every change including ones bypassing wx (api-compat fallback,
  *     direct localStorage.setItem from devtools, etc.)
  *   + Decouples panel UI from dimina runtime's wx implementation
- *   - debugger.attach is mutually exclusive with Chrome DevTools (F12).
- *     If a user opens DevTools on the simulator the debugger detaches and
- *     events stop flowing until they close it.
+ *   - debugger.attach is mutually exclusive with a REAL Chrome DevTools window
+ *     (F12) attaching to the same target from outside the broker. If a user
+ *     opens one, the shared session detaches externally and events stop
+ *     flowing until they close it.
  */
-import { type WebContents } from 'electron';
+import { type BrowserWindow, type WebContents } from 'electron';
 import { type ConnectionRegistry, type Disposable } from '@dimina-kit/electron-deck/main';
 import { type SyncStorageChange } from '../../../shared/ipc-channels.js';
 import { type SenderPolicy } from '../../utils/ipc-registry.js';
 import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
 import type { RenderInspector } from '../render-inspect/index.js';
+import { type CdpSessionBroker } from '../cdp-session/index.js';
 /**
  * Runtime async-storage handler (native-host). bridge-router routes async
  * `wx.setStorage`/`getStorage`/… here so they hit the SAME service-host `file://`
@@ -78,6 +85,28 @@ export interface SimulatorStorageOptions {
      * not adopted the connection layer compile and behave unchanged.
      */
     connections?: ConnectionRegistry;
+    /**
+     * Shared CDP session broker (see cdp-session/index.ts) that owns the
+     * simulator wc's debugger session lifecycle — network-forward independently
+     * captures Network.* events on the SAME simulator wc, and an unconditional
+     * `debugger.detach()` here (the pre-migration behavior) would kill ITS
+     * capture too, exactly as an unconditional detach on its side would kill
+     * ours. Absent → a private broker is created and owned for this module's
+     * lifetime (torn down on `dispose()`), so existing standalone callers/tests
+     * compile and behave unchanged, just without cross-module session sharing.
+     */
+    broker?: CdpSessionBroker;
+    /**
+     * Owning window (typically `mainWindow`). Scopes every simulator-webview
+     * discovery path (initial scan, `web-contents-created`, lazy re-find) to
+     * webviews that live inside THIS window — required in a multi-window
+     * workbench, where `webContents`/`app.on('web-contents-created')` are
+     * process-global and would otherwise let one window's instance attach to
+     * (and read/write through) another window's simulator. Optional so
+     * existing single-window callers/tests compile and keep their prior
+     * unscoped behavior.
+     */
+    window?: BrowserWindow;
 }
 export declare function setupSimulatorStorage(host: WebContents, options: SimulatorStorageOptions): SimulatorStorageHandle;
 //# sourceMappingURL=index.d.ts.map

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

@@ -2,22 +2,30 @@
  * SimulatorStorageWatcher
  *
  * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
- * and forwards `DOMStorage.*` events to the renderer host.
+ * and forwards `DOMStorage.*` events to the renderer host. The SAME simulator
+ * wc's debugger session is independently captured by network-forward
+ * (Network.* events); both acquire a lease from the shared `CdpSessionBroker`
+ * (see cdp-session/index.ts) rather than each attaching/detaching directly —
+ * releasing our own lease never forces a physical detach that would kill the
+ * other's capture.
  *
  * Trade-offs vs a preload-side localStorage.setItem hook:
  *   + Uses standard browser protocol; no preload injection
  *   + Captures every change including ones bypassing wx (api-compat fallback,
  *     direct localStorage.setItem from devtools, etc.)
  *   + Decouples panel UI from dimina runtime's wx implementation
- *   - debugger.attach is mutually exclusive with Chrome DevTools (F12).
- *     If a user opens DevTools on the simulator the debugger detaches and
- *     events stop flowing until they close it.
+ *   - debugger.attach is mutually exclusive with a REAL Chrome DevTools window
+ *     (F12) attaching to the same target from outside the broker. If a user
+ *     opens one, the shared session detaches externally and 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 { IpcRegistry } from '../../utils/ipc-registry.js';
 import { decodeStorageValue, encodeStorageValue, serviceStorage } from './service-storage-ops.js';
+import { createCdpSessionBroker } from '../cdp-session/index.js';
+import { windowHostsWebContents } from './window-scope.js';
 /** Async wx storage API names routed through the unified service-window store. */
 export const STORAGE_API_NAMES = new Set([
     'setStorage',
@@ -33,6 +41,17 @@ function isSimulatorWebview(wc) {
         return false;
     return wc.getURL().includes('simulator.html');
 }
+/**
+ * `win` undefined means no owning window was configured — the legacy
+ * unscoped behavior, kept so single-window callers/tests that don't pass
+ * `window` keep compiling and behaving unchanged. Every production call
+ * site (window-runtime-services.ts) always passes its window.
+ */
+function belongsToWindow(win, wc) {
+    if (!win)
+        return true;
+    return windowHostsWebContents(win, wc);
+}
 function safeOff(target, event, fn) {
     try {
         if (target.isDestroyed?.())
@@ -55,8 +74,12 @@ export function setupSimulatorStorage(host, options) {
             return null;
         return options.bridge.getServiceWc(getActiveAppId() ?? undefined);
     }
+    // Own (and dispose on this module's own dispose()) a private broker only
+    // when the caller didn't supply a shared one.
+    const ownsBroker = !options.broker;
+    const broker = options.broker ?? createCdpSessionBroker({ connections: options.connections });
     let attachedWc = null;
-    let attachDisposables = null;
+    let attachedLease = null;
     /**
      * Cached origin discovered via `executeJavaScript('location.origin')` on
      * first use. The simulator <webview> loads `simulator.html` from a stable
@@ -69,24 +92,21 @@ export function setupSimulatorStorage(host, options) {
         const appId = getActiveAppId();
         return appId ? `${appId}_` : null;
     }
+    /**
+     * Release OUR OWN lease on the simulator wc's shared session — never a
+     * physical `debugger.detach()`. The SAME wc is independently captured by
+     * network-forward (Network.* events); an unconditional detach here would
+     * kill its capture too. The broker (cdp-session/index.ts) alone decides
+     * when an actual detach happens.
+     */
     function detachFromSim() {
         if (!attachedWc)
             return;
-        const wc = attachedWc;
         attachedWc = null;
         cachedOrigin = null;
-        const ad = attachDisposables;
-        attachDisposables = null;
-        if (ad)
-            void ad.disposeAll().catch(() => { });
-        try {
-            if (!wc.isDestroyed() && wc.debugger.isAttached()) {
-                wc.debugger.detach();
-            }
-        }
-        catch {
-            // best-effort
-        }
+        const lease = attachedLease;
+        attachedLease = null;
+        lease?.dispose();
     }
     async function attachToSim(wc) {
         if (attachedWc === wc)
@@ -94,57 +114,30 @@ export function setupSimulatorStorage(host, options) {
         if (wc.isDestroyed())
             return;
         detachFromSim();
+        const lease = broker.acquire(wc);
+        if (!lease) {
+            console.warn('[storage-watcher] attach failed: debugger session unavailable');
+            return;
+        }
         try {
-            if (!wc.debugger.isAttached()) {
-                wc.debugger.attach('1.3');
-            }
-            await wc.debugger.sendCommand('DOMStorage.enable');
-            const attach = new DisposableRegistry();
-            attachDisposables = attach;
-            const onMessage = (_event, method, params) => forwardCdpMessage(method, params);
-            wc.debugger.on('message', onMessage);
-            attach.add(() => safeOff(wc.debugger, 'message', onMessage));
-            const onDetach = () => {
-                if (attachedWc === wc)
-                    attachedWc = null;
-            };
-            wc.debugger.on('detach', onDetach);
-            attach.add(() => safeOff(wc.debugger, 'detach', onDetach));
-            const onDestroyed = () => {
-                // When the attached wc is destroyed, the lingering attachDisposables
-                // hold listener refs to a wc that will never emit again. Dispose the
-                // registry here so debugger/wc listeners are removed deterministically
-                // and a subsequent attachToSim() starts from a clean slate.
-                if (attachedWc === wc) {
-                    attachedWc = null;
-                    const ad = attachDisposables;
-                    attachDisposables = null;
-                    if (ad)
-                        void ad.disposeAll().catch(() => { });
-                }
-            };
-            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;
+            await lease.send('DOMStorage.enable');
         }
         catch (e) {
             console.warn('[storage-watcher] attach failed:', e.message);
+            lease.dispose();
+            return;
         }
+        lease.onMessage((method, params) => forwardCdpMessage(method, params));
+        // Fires on external detach OR the wc being destroyed (see cdp-session's
+        // design doc) — either way our tracking of this wc as "attached" is stale.
+        lease.onDetach(() => {
+            if (attachedWc === wc) {
+                attachedWc = null;
+                attachedLease = null;
+            }
+        });
+        attachedWc = wc;
+        attachedLease = lease;
     }
     function forwardCdpMessage(method, params) {
         if (host.isDestroyed())
@@ -217,7 +210,7 @@ export function setupSimulatorStorage(host, options) {
     async function ensureAttached() {
         if (attachedWc && !attachedWc.isDestroyed())
             return;
-        const sim = findSimulatorWebContents();
+        const sim = findSimulatorWebContents(options.window);
         if (!sim)
             return;
         await attachToSim(sim);
@@ -411,7 +404,7 @@ export function setupSimulatorStorage(host, options) {
     // Attach to any simulator webview that already exists (project may have
     // been opened before this function runs).
     for (const wc of wcStatic.getAllWebContents()) {
-        if (isSimulatorWebview(wc)) {
+        if (isSimulatorWebview(wc) && belongsToWindow(options.window, wc)) {
             void attachToSim(wc);
             break;
         }
@@ -425,7 +418,7 @@ export function setupSimulatorStorage(host, options) {
         const sub = new DisposableRegistry();
         wcSubs.set(wc, sub);
         const onFinishLoad = () => {
-            if (isSimulatorWebview(wc))
+            if (isSimulatorWebview(wc) && belongsToWindow(options.window, wc))
                 void attachToSim(wc);
         };
         wc.on('did-finish-load', onFinishLoad);
@@ -474,7 +467,7 @@ export function setupSimulatorStorage(host, options) {
                 return null;
             return options.renderInspector.highlight(wc, sid);
         }
-        const sim = findSimulatorWebContents();
+        const sim = findSimulatorWebContents(options.window);
         if (!sim)
             return null;
         try {
@@ -493,7 +486,7 @@ export function setupSimulatorStorage(host, options) {
                 await options.renderInspector.unhighlight(wc);
             return;
         }
-        const sim = findSimulatorWebContents();
+        const sim = findSimulatorWebContents(options.window);
         if (!sim)
             return;
         try {
@@ -520,6 +513,12 @@ export function setupSimulatorStorage(host, options) {
     registry.add(ipc);
     // Detach active CDP session last
     registry.add(() => detachFromSim());
+    // Only detach sessions we self-attached if we own the broker's lifecycle —
+    // a shared/injected broker keeps serving other consumers past our dispose().
+    registry.add(() => {
+        if (ownsBroker)
+            broker.dispose();
+    });
     // ── 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
@@ -604,9 +603,12 @@ export function setupSimulatorStorage(host, options) {
 // bridge via executeJavaScript. Looked up independently from `attachedWc` so
 // it keeps working when the user opens Chrome DevTools and the storage
 // debugger detaches (debugger.attach is mutually exclusive with F12).
-function findSimulatorWebContents() {
+// Scoped to `win` for the same reason as the attach paths above — an
+// unscoped scan would resolve to whichever window's simulator comes first
+// in the process-global registry, not necessarily this instance's own.
+function findSimulatorWebContents(win) {
     for (const wc of wcStatic.getAllWebContents()) {
-        if (isSimulatorWebview(wc))
+        if (isSimulatorWebview(wc) && belongsToWindow(win, wc))
             return wc;
     }
     return null;

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

@@ -1,40 +1,2 @@
-/**
- * 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;
+export * from '@dimina-kit/electron-runtime/main/service-storage-ops';
 //# sourceMappingURL=service-storage-ops.d.ts.map