@dimina-kit/devtools 0.3.2-dev.20260525152421 → 0.3.2-dev.20260610082053

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/fs-channels.js

@@ -23,7 +23,7 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { sandboxBase } from '../../../simulator/vpath.js';
+import { sandboxBase } from '../../../shared/vpath.js';
 import { readDiskDir, readDiskFile, statDiskFile, writeDiskFile, } from './disk.js';
 /**
  * Defense-in-depth: a hostile preload could synthesize a `realPath` that

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,7 +28,7 @@
  * 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 { handleFsMkdir, handleFsRead, handleFsReaddir, handleFsStat, handleFsUnlink, handleFsWrite, } from './fs-channels.js';

package/dist/main/services/simulator-temp-files/request-handler.js

@@ -18,7 +18,7 @@
  *     into the renderer's network failure surface; we deliberately do not
  *     leak errno strings.
  */
-import { resolveVPath } from '../../../simulator/vpath.js';
+import { resolveVPath } from '../../../shared/vpath.js';
 import { readDiskFile } from './disk.js';
 const CACHE_CONTROL = 'public, max-age=31536000, immutable';
 function getHeader(headers, name) {

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/update/update-manager.d.ts

@@ -24,6 +24,16 @@ export declare class UpdateManager {
     private getCurrentVersion;
     private latestUpdate;
     private downloadedPath;
+    /**
+     * Whether this instance has already emitted `Available` once. The periodic
+     * check fires forever (interval default 1h), and downstream UI (qdmp shell
+     * renders a native toast / Notification) is not idempotent — every event
+     * stacks. We dedupe at the source: at most one Available per instance
+     * lifetime, regardless of how the upstream `info.version` shifts. The user
+     * already knows "an update exists"; tracking minor version bumps mid-
+     * session is not worth duplicating the toast.
+     */
+    private hasNotified;
     private timer;
     private initialTimer;
     private ipc;

package/dist/main/services/update/update-manager.js

@@ -7,6 +7,16 @@ export class UpdateManager {
     getCurrentVersion;
     latestUpdate = null;
     downloadedPath = null;
+    /**
+     * Whether this instance has already emitted `Available` once. The periodic
+     * check fires forever (interval default 1h), and downstream UI (qdmp shell
+     * renders a native toast / Notification) is not idempotent — every event
+     * stacks. We dedupe at the source: at most one Available per instance
+     * lifetime, regardless of how the upstream `info.version` shifts. The user
+     * already knows "an update exists"; tracking minor version bumps mid-
+     * session is not worth duplicating the toast.
+     */
+    hasNotified = false;
     timer = null;
     initialTimer = null;
     ipc;
@@ -85,9 +95,12 @@ export class UpdateManager {
     }
     async checkAndNotify() {
         const result = await this.check();
-        if (result.hasUpdate && result.info) {
-            this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
-        }
+        if (!result.hasUpdate || !result.info)
+            return;
+        if (this.hasNotified)
+            return;
+        this.hasNotified = true;
+        this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
     }
 }
 //# sourceMappingURL=update-manager.js.map

package/dist/main/services/views/devtools-tabs.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Customize the embedded Chrome DevTools front-end's panel tab bar.
+ *
+ * The right-panel DevTools (a WebContents rendering `devtools://`, attached to the
+ * service-host via `setDevToolsWebContents` + `openDevTools`) shows ALL its panels
+ * by default. For the mini-app workflow only Elements / Console / Network are
+ * meaningful in the default tab bar — but we do NOT want to delete the rest: they
+ * stay reachable on demand via the command menu (Cmd+Shift+P → "Show Sources" …).
+ *
+ * ── How (registry, not DOM) ─────────────────────────────────────────────────
+ * The modern ESM DevTools front-end does NOT expose `UI.ViewManager` on
+ * `globalThis`, so the tab bar can't be driven through the view manager. Panels
+ * register themselves via `registerViewExtension({id, location:'panel', persistence})`
+ * into a module-level registry; the official mutators are `registerViewExtension`,
+ * `getRegisteredViewExtensions` and `maybeRemoveViewExtension`. We:
+ *   1. `import('./ui/legacy/legacy.js')` to reach those functions (the real export
+ *      path on Electron 41 / Chromium ~138, verified at runtime);
+ *   2. whitelist-patch `registerViewExtension` so any future non-kept panel comes
+ *      in with `persistence:'transient'` (hidden from the default bar);
+ *   3. for the already-registered non-kept panels, `maybeRemoveViewExtension(id)`
+ *      then re-register a copy with `persistence:'transient'`.
+ * Transient views are not shown in the default tab bar but stay in the command
+ * menu — and because this is DevTools' own panel path, there is NO `>>` overflow
+ * or `×` close-button residue (which a DOM `display:none` hack leaves behind).
+ *
+ * ── Locale infobar ──────────────────────────────────────────────────────────
+ * The "DevTools is now available in 中文" banner is suppressed via the official
+ * host preference `disable-locale-info-bar` (a GLOBAL setting that lives in host
+ * preferences, NOT page localStorage), set through `InspectorFrontendHost.setPreference`.
+ *
+ * ── Degradation ─────────────────────────────────────────────────────────────
+ * If the ESM module can't be resolved, a bounded DOM `display:none` fallback hides
+ * the non-kept tabs (by visible name) so the bar still looks right. Everything is
+ * wrapped in try/catch in the injected realm and silently no-ops on any failure.
+ */
+/**
+ * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `network`.
+ */
+export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
+/**
+ * Build the `executeJavaScript` source injected into the DevTools front-end
+ * WebContents. The kept ids + display names are carried as JSON data literals
+ * (never interpolated as bare code), same discipline as the other injectors.
+ */
+export declare function buildCustomizeTabsScript(keptIds?: readonly string[]): string;
+//# sourceMappingURL=devtools-tabs.d.ts.map