@dimina-kit/devtools 0.3.2-dev.20260611063505 → 0.3.2-dev.20260611135124

package/dist/main/ipc/app.d.ts

@@ -1,4 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'preloadPath' | 'brandingProvider' | 'appName' | 'headerHeight' | 'senderPolicy'>): Disposable;
+export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'brandingProvider' | 'appName' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=app.d.ts.map

package/dist/main/ipc/app.js

@@ -1,18 +1,11 @@
-import fs from 'fs';
 import { AppChannel } from '../../shared/ipc-channels.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerAppIpc(ctx) {
     return new IpcRegistry(ctx.senderPolicy)
-        .handle(AppChannel.GetPreloadPath, () => {
-        return `file://${fs.realpathSync(ctx.preloadPath)}`;
-    })
         .handle(AppChannel.GetBranding, async () => {
         if (ctx.brandingProvider)
             return ctx.brandingProvider();
         return { appName: ctx.appName };
-    })
-        .handle(AppChannel.GetHeaderHeight, () => {
-        return ctx.headerHeight;
     });
 }
 //# sourceMappingURL=app.js.map

package/dist/main/ipc/index.d.ts

@@ -1,10 +1,8 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
-export { registerPanelsIpc } from './panels.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
-export { registerToolbarIpc } from './toolbar.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -1,10 +1,8 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
-export { registerPanelsIpc } from './panels.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
-export { registerToolbarIpc } from './toolbar.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/settings.d.ts

@@ -1,6 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import type { WorkbenchModule } from '../services/module.js';
-export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'workspace' | 'rendererDir' | 'senderPolicy' | 'windows'>): Disposable;
+export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'workspace' | 'rendererDir' | 'senderPolicy'>): Disposable;
 export declare const settingsModule: WorkbenchModule;
 //# sourceMappingURL=settings.d.ts.map

package/dist/main/ipc/settings.js

@@ -1,10 +1,9 @@
 import { app } from 'electron';
-import { openSettingsWindow } from '../app/launch.js';
 import { loadWorkbenchSettings, saveWorkbenchSettings, applyTheme, } from '../services/settings/index.js';
 import { WorkbenchSettingsChannel, SettingsChannel } from '../../shared/ipc-channels.js';
 import { DEFAULT_CDP_PORT } from '../../shared/constants.js';
 import { getMcpStatus } from '../services/mcp/status.js';
-import { SettingsConfigChangedSchema, SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, WorkbenchSettingsSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { SettingsConfigChangedSchema, SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSettingsIpc(ctx) {
@@ -44,15 +43,6 @@ export function registerSettingsIpc(ctx) {
             activePort: runtime.port,
             error: runtime.error,
         };
-    })
-        .handle(WorkbenchSettingsChannel.SetVisible, async (_, ...args) => {
-        const [visible] = validate(WorkbenchSettingsChannel.SetVisible, WorkbenchSettingsSetVisibleSchema, args);
-        if (visible) {
-            await openSettingsWindow(ctx);
-        }
-        else {
-            ctx.windows.closeSettingsWindow();
-        }
     })
         .handle(SettingsChannel.SetVisible, async (_, ...args) => {
         const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
@@ -67,7 +57,6 @@ export function registerSettingsIpc(ctx) {
         }
         else {
             ctx.views.hideSettings();
-            ctx.notify.settingsClosed();
         }
     })
         .on(SettingsChannel.ConfigChanged, async (_, ...args) => {
@@ -76,7 +65,6 @@ export function registerSettingsIpc(ctx) {
         if (projectPath) {
             await ctx.workspace.saveCompileConfig(projectPath, config);
         }
-        ctx.notify.settingsChanged(config);
     })
         .on(SettingsChannel.ProjectSettingsChanged, (_, ...args) => {
         const [patch] = validate(SettingsChannel.ProjectSettingsChanged, SettingsProjectSettingsChangedSchema, args);

package/dist/main/ipc/simulator-module.d.ts

@@ -1,8 +1,8 @@
 import type { WorkbenchModule } from '../services/module.js';
 /**
- * The 'simulator' built-in module fans out into three IPC registrars
- * (core simulator, panels, toolbar). Bundle them under a single module
- * so app.ts only sees one entry per BuiltinModuleId.
+ * The 'simulator' built-in module fans out into the simulator + views IPC
+ * registrars. Bundle them under a single module so app.ts only sees one
+ * entry per BuiltinModuleId.
  *
  * Bridge router (native-host PAGE_OPEN / NAV_ACTION / TAB_ACTION etc.) hooks
  * up unconditionally — the `__diminaNativeHost.enabled` flag in the simulator

package/dist/main/ipc/simulator-module.js

@@ -1,13 +1,11 @@
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 import { registerSimulatorIpc } from './simulator.js';
-import { registerPanelsIpc } from './panels.js';
-import { registerToolbarIpc } from './toolbar.js';
 import { installBridgeRouter } from './bridge-router.js';
 import { registerViewsIpc } from './views.js';
 /**
- * The 'simulator' built-in module fans out into three IPC registrars
- * (core simulator, panels, toolbar). Bundle them under a single module
- * so app.ts only sees one entry per BuiltinModuleId.
+ * The 'simulator' built-in module fans out into the simulator + views IPC
+ * registrars. Bundle them under a single module so app.ts only sees one
+ * entry per BuiltinModuleId.
  *
  * Bridge router (native-host PAGE_OPEN / NAV_ACTION / TAB_ACTION etc.) hooks
  * up unconditionally — the `__diminaNativeHost.enabled` flag in the simulator
@@ -19,8 +17,6 @@ export const simulatorModule = {
     setup: (ctx) => {
         const reg = new DisposableRegistry();
         reg.add(registerSimulatorIpc(ctx));
-        reg.add(registerPanelsIpc(ctx));
-        reg.add(registerToolbarIpc(ctx));
         reg.add(registerViewsIpc(ctx));
         installBridgeRouter(ctx);
         return reg;

package/dist/main/ipc/simulator.js

@@ -1,5 +1,5 @@
 import { ServiceHostChannel, SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
-import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorResizeSchema, SimulatorSetDeviceInfoSchema, SimulatorSetNativeBoundsSchema, SimulatorSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorSetDeviceInfoSchema, SimulatorSetNativeBoundsSchema, } from '../../shared/ipc-schemas.js';
 import { deviceInfoToHostEnv } from '../../shared/bridge-channels.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
@@ -11,10 +11,6 @@ export function registerSimulatorIpc(ctx) {
     })
         .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();
-    })
-        .handle(SimulatorChannel.Resize, (_, ...args) => {
-        const [simWidth] = validate(SimulatorChannel.Resize, SimulatorResizeSchema, args);
-        ctx.views.resize(simWidth);
     })
         .handle(SimulatorChannel.SetNativeBounds, (_, ...args) => {
         const [p] = validate(SimulatorChannel.SetNativeBounds, SimulatorSetNativeBoundsSchema, args);
@@ -38,13 +34,6 @@ export function registerSimulatorIpc(ctx) {
         if (serviceWc && !serviceWc.isDestroyed()) {
             serviceWc.send(ServiceHostChannel.HostEnvUpdate, deviceInfoToHostEnv(device));
         }
-    })
-        .handle(SimulatorChannel.SetVisible, (_, ...args) => {
-        const [visible, simWidth] = validate(SimulatorChannel.SetVisible, SimulatorSetVisibleSchema, args);
-        ctx.views.setVisible(visible, simWidth);
-    })
-        .handle(SimulatorCustomApiChannel.List, () => {
-        return ctx.simulatorApis.list();
     })
         .handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
         const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);

package/dist/main/runtime/miniapp-runtime.d.ts

@@ -1,39 +1,149 @@
 /**
  * MiniappRuntime — the stable, host-facing contract surface (foundation.md §3
- * "MiniappRuntime 契约" layer, P4).
+ * "MiniappRuntime 契约" layer).
  *
- * `WorkbenchContext` is the rich internal main-process state: runtime kernel +
- * host config + trust/infra plumbing, all mixed. Downstream hosts (qdmp, a
- * re-skin of devtools that depends ONLY on devtools) don't consume that whole
- * grab-bag — they drive the miniapp KERNEL: the view lifecycle (including the
- * host-controllable toolbar at `views.hostToolbar`), the cross-wc bridge, the
- * workspace, the custom-API registry, async storage, the appdata tap, the
- * connection layer, and the main→renderer notifier.
+ * HAND-WRITTEN, not derived from `WorkbenchContext`. A `Pick`-style projection
+ * would drag every nested internal service type (ViewManager,
+ * BridgeRouterHandle, SimulatorApiRegistry, Electron WebContents…) onto the
+ * public semver face, so any internal refactor of those services becomes an
+ * unreviewed breaking change for downstream hosts (qdmp). Instead this module
+ * names ONLY the audited downstream consumption surface, with structural DTOs
+ * and zero Electron types — non-Electron consumers can compile against it.
  *
- * This module NAMES that kernel as an explicit, documented contract so the
- * surface a host depends on is compiler-enforced and versionable, instead of
- * "whatever fields of WorkbenchContext you happen to reach for". Config inputs
- * (appName / panels / apiNamespaces / branding / project templates) are the
- * host's INPUT, not part of the runtime it consumes; trust/infra
- * (senderPolicy / trustedWindowSenderIds / registry / toolbar action-table)
- * stay internal.
- *
- * Derived via `Pick<WorkbenchContext, …>` so the field TYPES never drift from
- * the real implementation — `MiniappRuntime` is a view onto `WorkbenchContext`,
- * and the conformance assertion below fails to compile the moment the context
- * stops satisfying the contract.
+ * Contract rules:
+ *  - Members are FUNCTION-VALUED PROPERTIES (`m: (x) => r`), never method
+ *    syntax: under strictFunctionTypes method signatures compare bivariantly,
+ *    which would let a wrongly-narrowed implementation or host override slip
+ *    past the drift sentinel.
+ *  - `workspace.openProject` stays writable (no `readonly`): qdmp gates
+ *    project permissions by reassigning it (documented monkey-patch contract).
+ *  - `windows` is an OPAQUE handle (`object`): hosts pass it through to
+ *    framework helpers but never reach into it (no BrowserWindow leak).
  *
- * The host-controllable toolbar WebContentsView hangs off `views.hostToolbar`
- * (a ViewManager concern), so it's reachable through the contract WITHOUT a 9th
- * top-level member — `runtime.views.hostToolbar.loadURL(...)`.
+ * `asMiniappRuntime(ctx)` is an identity return — the contract is a typed
+ * VIEW onto the live context, not a snapshot/projection. That is what makes
+ * the monkey-patch contract work (a copied projection would receive the patch
+ * on a dead object), and its `return ctx` doubles as the assignment-compat
+ * sentinel: if an internal service drifts away from the contract, compilation
+ * breaks HERE, in this package's CI — not in a downstream host's upgrade.
  */
 import type { WorkbenchContext } from '../services/workbench-context.js';
-/** The stable miniapp-kernel surface a downstream host (qdmp) consumes. */
-export type MiniappRuntime = Pick<WorkbenchContext, 'views' | 'bridge' | 'workspace' | 'simulatorApis' | 'storageApi' | 'appData' | 'connections' | 'notify'>;
+/** Compile-status payload broadcast to hosts via `notify.projectStatus`. */
+export interface MiniappProjectStatusPayload {
+    status: string;
+    message: string;
+    /** True when the status update is emitted by the file-watcher rebuild loop. */
+    hotReload?: boolean;
+}
+/**
+ * Host-facing control surface for the toolbar WebContentsView — the exact
+ * post-R2 message-channel surface (`send`/`onMessage`), with no `webContents`
+ * escape hatch (that would put Electron types on the contract).
+ */
+export interface MiniappHostToolbar {
+    /**
+     * The host's own `webPreferences.preload` for the toolbar view (purely
+     * additive — never replaces the framework's session-resident height
+     * advertiser). Must be set before the view is (re)created; `null` (default)
+     * means "no host preload".
+     */
+    setPreloadPath: (path: string | null) => void;
+    /** Load a local file into the toolbar view (lazy-creates the view). */
+    loadFile: (path: string) => Promise<void>;
+    /** Load a URL into the toolbar view (lazy-creates the view). */
+    loadURL: (url: string) => Promise<void>;
+    /**
+     * Post `{ channel, payload }` to the toolbar page. Gated and non-queueing:
+     * returns false (delivering nothing, creating no view) while there is no
+     * live toolbar webContents or the current load's MessagePort handshake
+     * hasn't completed; true once the envelope went out.
+     */
+    send: (channel: string, payload: unknown) => boolean;
+    /**
+     * Register a host-side handler for messages the toolbar page sends via
+     * `window.diminaHostToolbar.send(channel, payload)`. May be called before
+     * the view exists; survives page reloads. `dispose()` detaches (idempotent).
+     */
+    onMessage: (channel: string, handler: (payload: unknown) => void) => {
+        dispose: () => void;
+    };
+    /**
+     * Pin (`{ fixed }`) or unpin (`'auto'`) the toolbar strip height. `'auto'`
+     * (default) lets the in-page height advertiser drive the placeholder.
+     */
+    setHeightMode: (mode: 'auto' | {
+        fixed: number;
+    }) => void;
+}
+/**
+ * The audited workspace surface: project list membership, session lifecycle,
+ * and minimal session state. Thumbnails / per-project settings / providers
+ * stay internal.
+ */
+export interface MiniappWorkspace {
+    /** True while a project session is open. */
+    hasActiveSession: () => boolean;
+    /** Absolute path of the open project, or '' when none. */
+    getProjectPath: () => string;
+    /**
+     * Open (compile + start) a project session. WRITABLE BY CONTRACT: hosts may
+     * reassign this member to wrap it (e.g. a permission gate) — every internal
+     * caller routes through the live property, so the wrapper always intercepts.
+     */
+    openProject: (projectPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Tear down the active session (no-op when none). */
+    closeProject: () => Promise<void>;
+    /** True when the directory is already in the project list. */
+    hasProject: (dirPath: string) => Promise<boolean>;
+    /** Add a directory to the project list. */
+    addProject: (dirPath: string) => Promise<unknown>;
+    /**
+     * Minimal live-session DTO, or null when no session. Deliberately excludes
+     * the session's own `close` — hosts end sessions via `closeProject`, never
+     * behind the workspace's back.
+     */
+    getSession: () => {
+        appInfo: unknown;
+    } | null;
+}
+/**
+ * The stable miniapp-kernel surface a downstream host (qdmp) consumes.
+ * Compiler-enforced and versionable: widening it back toward internal
+ * plumbing is a deliberate semver decision, not an accident of projection.
+ */
+export interface MiniappRuntime {
+    /** Absolute path to the devtools renderer dist directory. */
+    rendererDir: string;
+    /** View layer — only the host-owned toolbar control is public. */
+    views: {
+        readonly hostToolbar: MiniappHostToolbar;
+    };
+    /** Project + session workspace (see {@link MiniappWorkspace}). */
+    workspace: MiniappWorkspace;
+    /** Main → renderer notifier — only the compile-status broadcast is public. */
+    notify: {
+        projectStatus: (payload: MiniappProjectStatusPayload) => void;
+    };
+    /** Lifecycle sink: hosts register their own teardown via `registry.add`. */
+    registry: {
+        add: (dispose: () => void) => unknown;
+    };
+    /**
+     * Opaque window-service handle. Pass it through to framework helpers
+     * (e.g. `openSettingsWindow`); it exposes nothing to reach into.
+     */
+    windows: object;
+}
 /**
- * Project a full `WorkbenchContext` down to its `MiniappRuntime` view. Hosts
- * call this to get a value typed to exactly the contract — no wider access to
- * the context's internals leaks through.
+ * View a full `WorkbenchContext` as its `MiniappRuntime` contract. Identity
+ * return: the result IS the live context, typed down to the contract, so host
+ * monkey-patches (e.g. `runtime.workspace.openProject = gated`) land on the
+ * real object. The `return ctx` is also the compile-time drift sentinel — if
+ * `WorkbenchContext` ever stops structurally satisfying the contract, THIS
+ * stops compiling.
  */
 export declare function asMiniappRuntime(ctx: WorkbenchContext): MiniappRuntime;
 //# sourceMappingURL=miniapp-runtime.d.ts.map

package/dist/main/runtime/miniapp-runtime.js

@@ -1,17 +1,12 @@
 /**
- * Project a full `WorkbenchContext` down to its `MiniappRuntime` view. Hosts
- * call this to get a value typed to exactly the contract — no wider access to
- * the context's internals leaks through.
+ * View a full `WorkbenchContext` as its `MiniappRuntime` contract. Identity
+ * return: the result IS the live context, typed down to the contract, so host
+ * monkey-patches (e.g. `runtime.workspace.openProject = gated`) land on the
+ * real object. The `return ctx` is also the compile-time drift sentinel — if
+ * `WorkbenchContext` ever stops structurally satisfying the contract, THIS
+ * stops compiling.
  */
 export function asMiniappRuntime(ctx) {
     return ctx;
 }
-/**
- * Compile-time conformance guard: if `WorkbenchContext` ever stops structurally
- * satisfying `MiniappRuntime` (a kernel field renamed / its type narrowed),
- * THIS line fails `tsc`, catching the contract break at build time. The runtime
- * value is unused.
- */
-const _conformance = (ctx) => ctx;
-void _conformance;
 //# sourceMappingURL=miniapp-runtime.js.map

package/dist/main/services/layout/index.d.ts

@@ -1,20 +1,9 @@
-/** Layout constants (px) */
-export declare const SPLITTER_W = 4;
-/**
- * X coordinate where the legacy right-side overlay starts.
- */
-export declare function getRightX(simWidth: number): number;
 export interface Bounds {
     x: number;
     y: number;
     width: number;
     height: number;
 }
-export declare function computeRightPanelBounds(contentWidth: number, contentHeight: number, simWidth: number, headerHeight: number): Bounds;
-/**
- * Compute bounds for DevTools view (same as right panel, overlays it).
- */
-export declare function computeSimulatorBounds(contentWidth: number, contentHeight: number, simWidth: number, headerHeight: number): Bounds;
 /**
  * NATIVE-HOST ONLY. Translate the renderer-measured simulator panel REGION rect
  * (CSS px from the main window content top-left — the flex:1 placeholder slot)

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

@@ -1,26 +1,3 @@
-/** Layout constants (px) */
-export const SPLITTER_W = 4;
-/**
- * X coordinate where the legacy right-side overlay starts.
- */
-export function getRightX(simWidth) {
-    return simWidth + SPLITTER_W;
-}
-export function computeRightPanelBounds(contentWidth, contentHeight, simWidth, headerHeight) {
-    const x = getRightX(simWidth);
-    return {
-        x,
-        y: headerHeight,
-        width: Math.max(1, contentWidth - x),
-        height: Math.max(1, contentHeight - headerHeight),
-    };
-}
-/**
- * Compute bounds for DevTools view (same as right panel, overlays it).
- */
-export function computeSimulatorBounds(contentWidth, contentHeight, simWidth, headerHeight) {
-    return computeRightPanelBounds(contentWidth, contentHeight, simWidth, headerHeight);
-}
 /**
  * NATIVE-HOST ONLY. Translate the renderer-measured simulator panel REGION rect
  * (CSS px from the main window content top-left — the flex:1 placeholder slot)

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -45,16 +45,10 @@ export interface RendererNotifier {
     projectStatus(payload: ProjectStatusPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */
     windowNavigateBack(): void;
-    /** Tell the main renderer the embedded settings overlay has been closed. */
-    settingsClosed(): void;
-    /** Broadcast an updated compile config to the main renderer. */
-    settingsChanged(config: CompileConfig): void;
     /** Tell the main renderer the compile popover has been closed. */
     popoverClosed(): void;
     /** Ask the main renderer to relaunch the simulator with a new config. */
     popoverRelaunch(config: CompileConfig): void;
-    /** Tell the main renderer the toolbar actions list has changed. */
-    toolbarActionsChanged(): void;
     /**
      * Push the reserved host-toolbar height to the main renderer so its toolbar
      * placeholder div resizes (closes the host-toolbar dynamic-height loop).

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, ToolbarChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -27,21 +27,12 @@ export function createRendererNotifier(ctx) {
         windowNavigateBack() {
             sendToMain(WindowChannel.NavigateBack);
         },
-        settingsClosed() {
-            sendToMain(SettingsChannel.Closed);
-        },
-        settingsChanged(config) {
-            sendToMain(SettingsChannel.Changed, config);
-        },
         popoverClosed() {
             sendToMain(PopoverChannel.Closed);
         },
         popoverRelaunch(config) {
             sendToMain(PopoverChannel.Relaunch, config);
         },
-        toolbarActionsChanged() {
-            sendToMain(ToolbarChannel.ActionsChanged);
-        },
         hostToolbarHeightChanged(height) {
             sendToMain(ViewChannel.HostToolbarHeightChanged, height);
         },

package/dist/main/services/service-host-pool/pool.d.ts

@@ -5,10 +5,11 @@ import { BrowserWindow } from 'electron';
  * Design source: `packages/devtools/docs/prewarm-webview.md`. WIRED into
  * native-host via `bridge-router.handleSpawn` (acquire) + `disposeAppSession`
  * (release / releaseDestroyed), opt-in behind `DIMINA_PREWARM_POOL_SIZE`
- * (default OFF). Default-arch (`view-manager.attachSimulator`) is NOT pooled —
- * its simulator is a `<webview>` tag, which Electron can't reparent a pre-warmed
- * WebContents into (doc §5 Phase 4, blocked by that hard limit, not by missing
- * work here).
+ * (default OFF). Only the SERVICE-HOST window is pooled; the simulator content
+ * WebContentsView (`view-manager.attachNativeSimulator`) is created fresh per
+ * attach. (The historical `<webview>`-tag default arch was never poolable —
+ * Electron can't reparent a pre-warmed WebContents into a `<webview>`; doc §5
+ * Phase 4 — and that route has since been deleted outright.)
  *
  * Lifecycle of a pool entry:
  *   warming   — BrowserWindow constructed, page loading

package/dist/main/services/views/host-toolbar-port-channel.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Gated narrow channel between the main process and the host-toolbar
+ * WebContentsView's page, over a per-load transferred MessagePort.
+ *
+ * Why a MessagePort and not plain IPC: the toolbar page is HOST-ARBITRARY
+ * content. A dedicated port pair gives it exactly one pipe whose main-side end
+ * lives in this module — the page never gains a generic `ipcRenderer` reach
+ * into the ~72 internal devtools channels, and main-side inbound traffic is
+ * validated at this single waist.
+ *
+ * Lifecycle (per-load handshake):
+ *  - On every toolbar-wc `did-finish-load` main builds a fresh
+ *    `MessageChannelMain`, transfers port2 to the new document via
+ *    `wc.postMessage(ViewChannel.HostToolbarPort, null, [port2])`, keeps
+ *    port1 and `start()`s it. The previous port1 (if any) is closed first —
+ *    its document is gone.
+ *  - `onMessage` registrations are CONTROL-level (this module's registry), not
+ *    per-port: they may be made before any view exists and survive page
+ *    reloads / wc rebuilds, because each new handshake dispatches into the
+ *    same registry.
+ *  - `send` is gated and non-queueing: `false` means "not delivered, ever" —
+ *    no toolbar view is conjured, nothing is buffered for a later handshake.
+ *  - A port1 `'close'` event (the renderer end died without a re-handshake
+ *    yet) drops the live-port reference so `send` reports `false` instead of
+ *    posting into a dead pipe.
+ *  - NAVIGATION INVALIDATES THE PORT. The port pair belongs to one DOCUMENT,
+ *    so starting a navigation that replaces that document closes port1 and
+ *    `send` returns `false` until the new document's `did-finish-load`
+ *    handshake. Two paths:
+ *      (a) host-initiated `hostToolbar.loadURL/loadFile` calls `invalidate()`
+ *          synchronously AT INITIATION (view-manager does this before the
+ *          `webContents.loadURL/loadFile` await), so a same-tick `send` can
+ *          never report `true` for an envelope posted into the document the
+ *          load is about to replace;
+ *      (b) page-initiated navigation (location.href / reload) is caught by a
+ *          `did-start-navigation` listener — guarded to the ACTIVE wc,
+ *          main-frame, cross-document only. Same-document navigations
+ *          (anchors, pushState, history) and subframe navigations do NOT
+ *          invalidate: the document the port lives in survives those, and no
+ *          main-frame `did-finish-load` would follow to ever restore the
+ *          channel.
+ *
+ * Envelope both directions: `{ channel: string, payload: unknown }`. Inbound
+ * data that is not an object with a string `channel` is DROPPED without
+ * throwing (the counterpart is arbitrary host content).
+ */
+import type { WebContents } from 'electron';
+/** Handle returned by `onMessage`; `dispose()` detaches (idempotent). */
+export interface HostToolbarMessageSubscription {
+    dispose(): void;
+}
+export interface HostToolbarPortChannel {
+    /**
+     * Hook a freshly created toolbar webContents: registers the
+     * `did-finish-load` (per-load handshake) and `destroyed` (drop the live
+     * port) listeners via `wc.on(...)`. Call exactly once per wc, right after
+     * the view is created.
+     */
+    attach(wc: WebContents): void;
+    /**
+     * Drop the live port NOW (close + clear): the document it belongs to is
+     * being replaced. Called by view-manager synchronously when the HOST
+     * initiates a `loadURL`/`loadFile` — the host-initiated half of the
+     * navigation-invalidates contract (the page-initiated half is the
+     * `did-start-navigation` listener `attach` installs). `send` returns false
+     * from this call until the next `did-finish-load` handshake. Idempotent.
+     */
+    invalidate(): void;
+    /** Register a control-level inbound handler for `channel`. */
+    onMessage(channel: string, handler: (payload: unknown) => void): HostToolbarMessageSubscription;
+    /**
+     * Post `{ channel, payload }` to the toolbar page over the live port.
+     * Returns false (delivering NOTHING, creating NOTHING) when there is no
+     * live toolbar wc, the current load's handshake hasn't completed, or a
+     * document-replacing navigation is in flight (see `invalidate`).
+     */
+    send(channel: string, payload: unknown): boolean;
+    /**
+     * Teardown (view-manager `disposeAll`): close the live port, sweep the
+     * handler registry, refuse further handshakes. Subsequent `send` returns
+     * false; late `dispose()` of an old subscription stays a no-op.
+     */
+    dispose(): void;
+}
+export declare function createHostToolbarPortChannel(opts: {
+    /**
+     * Is `wc` still the manager's CURRENT live toolbar webContents? Guards a
+     * stale wc's late `did-finish-load` from hijacking the channel after a
+     * rebuild swapped the view out underneath it.
+     */
+    isCurrent: (wc: WebContents) => boolean;
+}): HostToolbarPortChannel;
+//# sourceMappingURL=host-toolbar-port-channel.d.ts.map