@dimina-kit/devtools 0.3.2-dev.20260611063505 → 0.4.0-dev.20260612025610

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/menu/index.d.ts

@@ -1,3 +1,3 @@
-import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function installAppMenu(ctx: WorkbenchContext): void;
+import type { MenuContext } from '../../shared/types.js';
+export declare function installAppMenu(ctx: MenuContext): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/menu/index.js

@@ -1,5 +1,7 @@
 import { Menu } from 'electron';
-import { openSettingsWindow } from '../app/launch.js';
+// The built-in menu consumes the narrow MenuContext, the same surface a host
+// menuBuilder receives — proof that the hand-written contract covers the
+// real internal consumption (settings entry + navigate-back).
 export function installAppMenu(ctx) {
     const template = [
         {
@@ -8,7 +10,7 @@ export function installAppMenu(ctx) {
                 {
                     label: '开发工具设置',
                     click: () => {
-                        void openSettingsWindow(ctx).catch(() => { });
+                        void ctx.openSettings().catch(() => { });
                     },
                 },
                 { type: 'separator' },

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

@@ -1,39 +1,217 @@
 /**
  * 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).
  *
- * 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;
+}
+/**
+ * Structured shape of `getSession().appInfo` — the doc-promised
+ * (`host-migration.md` "appInfo 已结构化") DTO, named so hosts can type what
+ * they receive without deep imports or casts.
+ *
+ * `appId` is REQUIRED: the renderer derives its IPC scoping from it and the
+ * default devkit adapter always supplies one (fallback included). A custom
+ * adapter that returns a session without a string `appId` is rejected at the
+ * `openProject` boundary (see workspace-service.ts) — it never becomes the
+ * active session. The decorative rest stays optional: `name`/`path` come from
+ * the devkit adapter, `appName` from the devtools-side mirror; minimal custom
+ * adapters may omit all three.
+ */
+export interface MiniappSessionAppInfo {
+    appId: string;
+    name?: string;
+    path?: string;
+    appName?: string;
+}
+/**
+ * The page-side bridge the framework injects into the host-toolbar WCV as
+ * `window.diminaHostToolbar` (see src/preload/runtime/host-toolbar-port.ts).
+ * Declared here (the electron-free contract module) so TypeScript toolbar
+ * pages can type the bridge without hand-rolling — and without importing
+ * anything Electron-flavored.
+ *
+ * Shape mirrors the injected bridge EXACTLY:
+ *  - `send` returns void (pre-handshake sends are queued, bounded at 128);
+ *  - `onMessage` returns a BARE un-subscribe function — unlike the main-side
+ *    control's `{ dispose }` — because that is what the preload exposes.
+ * Both throw a `TypeError` synchronously when `channel` is not a non-empty
+ * string (parity with the main side's `onMessage` guard).
+ */
+export interface DiminaHostToolbarPageBridge {
+    send: (channel: string, payload: unknown) => void;
+    onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
+}
+declare global {
+    interface Window {
+        /**
+         * Present ONLY inside the host-toolbar WebContentsView's main frame
+         * (guarded injection — see host-toolbar-runtime.ts); optional everywhere
+         * else, so page code must runtime-guard before use.
+         */
+        diminaHostToolbar?: DiminaHostToolbarPageBridge;
+    }
+}
+/**
+ * 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;
+    };
+    /**
+     * Observe handshake readiness. Fires the handler once per load generation,
+     * exactly when the toolbar page's MessagePort handshake completes (i.e.
+     * when `send` flips to true). Registering while the channel is already
+     * ready fires once asynchronously on a microtask (missed-signal guard);
+     * a reload / re-handshake fires registered handlers again. `dispose()`
+     * detaches (idempotent).
+     */
+    onReady: (handler: () => void) => {
+        dispose: () => void;
+    };
+    /**
+     * Pin (`{ fixed }`) or unpin (`'auto'`) the toolbar strip height. `'auto'`
+     * (default) lets the in-page height advertiser drive the placeholder.
+     * `{ fixed }` values must be finite and non-negative — anything else throws
+     * a `TypeError` synchronously and leaves the standing mode untouched.
+     */
+    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. `appInfo` is structured (see
+     * {@link MiniappSessionAppInfo}) — no casting required.
+     */
+    getSession: () => {
+        appInfo: MiniappSessionAppInfo;
+    } | 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 {
+    /** 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`.
+     * Accepts BOTH disposal idioms — a `{ dispose }` object (what
+     * `hostToolbar.onMessage`/`onReady` return) or a bare `() => void` —
+     * matching the live registry, so `registry.add(sub)` works without the
+     * `registry.add(() => sub.dispose())` wrapper.
+     */
+    registry: {
+        add: (d: {
+            dispose: () => void;
+        } | (() => void)) => void;
+    };
+    /**
+     * Open (or re-focus) the standalone workbench-settings window. Replaces the
+     * retired `windows` opaque pass-through (whose only documented purpose —
+     * `openSettingsWindow(ctx)` — could never typecheck from the contract) and
+     * the `rendererDir` member that existed solely to feed it; hosts needing
+     * the renderer dist path use the `/paths` export instead.
+     */
+    openSettings: () => Promise<void>;
+}
 /**
- * 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