@dimina-kit/devtools 0.4.0-dev.20260803105710 → 0.4.0-dev.20260828092243

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

@@ -35,10 +35,14 @@
  */
 /**
  * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
- * ids, unchanged for many Chromium releases): `elements`, `console`, `network`,
- * `sources`. Sources stays so a source-link click that isn't routed to Monaco
- * (build/runtime chunks, framework frames) still has a panel to reveal in instead
- * of silently no-op'ing.
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `sources`,
+ * `network`. Sources stays so a source-link click NOT routed to Monaco (build/
+ * runtime chunks, framework frames) still has a panel to reveal in instead of
+ * silently no-op'ing. ORDERING NOTE: these stay in DevTools' DEFAULT visual
+ * order (Sources between Console and Network). We deliberately do NOT move
+ * Sources after Network: reordering the DOM nodes desyncs the front-end's
+ * click→panel mapping (it indexes tabs by child position), which made clicking
+ * Network activate Sources.
  */
 export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
 /**
@@ -47,4 +51,20 @@ export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
  * (never interpolated as bare code), same discipline as the other injectors.
  */
 export declare function buildCustomizeTabsScript(keptIds?: readonly string[]): string;
+/**
+ * Build the `executeJavaScript` source that forces the DevTools front-end to
+ * render its context menus as PAGE menus (soft menus) instead of asking the
+ * host via `showContextMenuAtPoint()`.
+ *
+ * The embedded DevTools front-end decides per-menu in `ContextMenu#show()`:
+ * `this.useSoftMenu || InspectorFrontendHostInstance.isHostedMode()`. On a
+ * self-built WebContentsView Electron leaves both false and does not answer
+ * `showContextMenuAtPoint()`, so right-click menus (复制为 cURL / Copy / …)
+ * never appear. Forcing the host-wide `isHostedMode()` true instead breaks the
+ * front-end's target data flow (Console/Network panels go empty), so we take
+ * the narrow path: patch the ContextMenu prototype so every menu shows as a
+ * page-rendered soft menu — same rendering the VS Code embedding uses, without
+ * touching the host-mode flag or any other front-end behaviour.
+ */
+export declare function buildDevtoolsSoftMenuScript(): string;
 //# sourceMappingURL=devtools-tabs.d.ts.map

package/dist/main/services/views/devtools-tabs.js

@@ -35,12 +35,16 @@
  */
 /**
  * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
- * ids, unchanged for many Chromium releases): `elements`, `console`, `network`,
- * `sources`. Sources stays so a source-link click that isn't routed to Monaco
- * (build/runtime chunks, framework frames) still has a panel to reveal in instead
- * of silently no-op'ing.
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `sources`,
+ * `network`. Sources stays so a source-link click NOT routed to Monaco (build/
+ * runtime chunks, framework frames) still has a panel to reveal in instead of
+ * silently no-op'ing. ORDERING NOTE: these stay in DevTools' DEFAULT visual
+ * order (Sources between Console and Network). We deliberately do NOT move
+ * Sources after Network: reordering the DOM nodes desyncs the front-end's
+ * click→panel mapping (it indexes tabs by child position), which made clicking
+ * Network activate Sources.
  */
-export const DEVTOOLS_KEPT_VIEW_IDS = ['elements', 'console', 'network', 'sources'];
+export const DEVTOOLS_KEPT_VIEW_IDS = ['elements', 'console', 'sources', 'network'];
 /**
  * Build the `executeJavaScript` source injected into the DevTools front-end
  * WebContents. The kept ids + display names are carried as JSON data literals
@@ -50,20 +54,15 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
     // Kept panels are matched by view id (registry path) and by visible NAME (DOM
     // fallback path); the DevTools UI may be EN or ZH, so include both.
     const NAME_MAP = {
-        elements: ['Elements', '元素'], console: ['Console', '控制台'], network: ['Network', '网络'],
-        sources: ['Sources', '来源', '源代码'],
+        elements: ['Elements', '元素'], console: ['Console', '控制台'],
+        sources: ['Sources', '来源', '源代码'], network: ['Network', '网络'],
     };
     const keepNames = keptIds.flatMap((id) => NAME_MAP[id] ?? [id]);
     const keepIdsJson = JSON.stringify(JSON.stringify([...keptIds]));
     const keepNamesJson = JSON.stringify(JSON.stringify(keepNames));
-    const srcNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.sources));
-    const netNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.network));
     return `(function(){try{
     var KEEPID = new Set(JSON.parse(${keepIdsJson}));
     var KEEPNAME = new Set(JSON.parse(${keepNamesJson}));
-    var SRCNAME = new Set(JSON.parse(${srcNamesJson}));
-    var NETNAME = new Set(JSON.parse(${netNamesJson}));
-    var WANT_SOURCES_LAST = KEEPID.has('sources');
     // (1) Locale infobar — official host-preference suppression (NOT localStorage).
     try { var IFH=globalThis.InspectorFrontendHost; if(IFH&&typeof IFH.setPreference==='function'){ IFH.setPreference('disable-locale-info-bar','true'); } }catch(_){}
     function deepCollect(sel,cap){ var out=[],seen=0,stack=[document]; while(stack.length&&seen<(cap||40000)){ var root=stack.pop(); try{var m=root.querySelectorAll?root.querySelectorAll(sel):[];for(var i=0;i<m.length;i++)out.push(m[i]);}catch(_){} try{var all=root.querySelectorAll?root.querySelectorAll('*'):[];for(var j=0;j<all.length;j++){seen++;if(all[j].shadowRoot)stack.push(all[j].shadowRoot);}}catch(_){} } return out; }
@@ -94,15 +93,6 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
         if(!handled){ var FALL=['timeline','resources','heap-profiler','security','lighthouse','chrome-recorder','coverage','linear-memory-inspector','sensors','rendering','animations','autofill-view','medias','issues-pane']; for(var fr=0;fr<FALL.length;fr++){ try{ if(!KEEPID.has(FALL[fr])) maybeRemove(FALL[fr]); }catch(_){} } }
       } else { domFallback(); }
     })();
-    // Keep Sources LAST in the bar (after Network). Default DevTools order puts
-    // Sources between Console and Network; nudge it to just after Network. Runs in
-    // BOTH paths (registry removal leaves the kept tabs in default order). Self-
-    // stable: once Sources follows Network the condition no longer holds.
-    if(WANT_SOURCES_LAST){ var ro=0,rt=setInterval(function(){ ro++; try{
-      var tabs=deepCollect('[role="tab"]'),src=null,net=null;
-      for(var i=0;i<tabs.length;i++){ var n=txt(tabs[i]); if(SRCNAME.has(n))src=tabs[i]; else if(NETNAME.has(n))net=tabs[i]; }
-      if(src&&net&&src.parentElement&&src.parentElement===net.parentElement&&(src.compareDocumentPosition(net)&Node.DOCUMENT_POSITION_FOLLOWING)){ net.parentElement.insertBefore(src,net.nextSibling); }
-    }catch(_){} if(ro>120)clearInterval(rt); },60); }
     // DOM fallback: only if the ESM module couldn't be resolved at all.
     function domFallback(){ var cachedBar=null;
       function findBar(){ if(cachedBar&&cachedBar.isConnected)return cachedBar; cachedBar=null; var tabs=deepCollect('[role="tab"]'); var a=null; for(var i=0;i<tabs.length;i++){if(KEEPNAME.has(txt(tabs[i]))){a=tabs[i];break;}} if(!a)return null; var p=a.parentElement; while(p){try{if(p.querySelectorAll('[role="tab"]').length>1){cachedBar=p;return p;}}catch(_){} p=p.parentElement;} cachedBar=a.parentElement; return cachedBar; }
@@ -110,4 +100,33 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
       var tr=0,t=setInterval(function(){tr++;try{apply();}catch(_){}if(tr>120)clearInterval(t);},60); try{apply();}catch(_){} }
   }catch(_){}})()`;
 }
+/**
+ * Build the `executeJavaScript` source that forces the DevTools front-end to
+ * render its context menus as PAGE menus (soft menus) instead of asking the
+ * host via `showContextMenuAtPoint()`.
+ *
+ * The embedded DevTools front-end decides per-menu in `ContextMenu#show()`:
+ * `this.useSoftMenu || InspectorFrontendHostInstance.isHostedMode()`. On a
+ * self-built WebContentsView Electron leaves both false and does not answer
+ * `showContextMenuAtPoint()`, so right-click menus (复制为 cURL / Copy / …)
+ * never appear. Forcing the host-wide `isHostedMode()` true instead breaks the
+ * front-end's target data flow (Console/Network panels go empty), so we take
+ * the narrow path: patch the ContextMenu prototype so every menu shows as a
+ * page-rendered soft menu — same rendering the VS Code embedding uses, without
+ * touching the host-mode flag or any other front-end behaviour.
+ */
+export function buildDevtoolsSoftMenuScript() {
+    return `(function(){
+    try {
+      var C = globalThis.EUI && globalThis.EUI.ContextMenu && globalThis.EUI.ContextMenu.ContextMenu;
+      if (C && C.prototype && typeof C.prototype.show === 'function') {
+        var origShow = C.prototype.show;
+        C.prototype.show = function() {
+          this.useSoftMenu = true;
+          return origShow.apply(this, arguments);
+        };
+      }
+    } catch (_) {}
+  })()`;
+}
 //# sourceMappingURL=devtools-tabs.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import type { WebContents } from 'electron';
+import { type HostSlotMessageSubscription, type HostSlotPortChannel } from './host-slot-port-channel.js';
+export type HostDialogMessageSubscription = HostSlotMessageSubscription;
+export type HostDialogPortChannel = HostSlotPortChannel;
+export declare function createHostDialogPortChannel(opts: {
+    /**
+     * Is `wc` still the manager's CURRENT live dialog 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;
+}): HostDialogPortChannel;
+//# sourceMappingURL=host-dialog-port-channel.d.ts.map

package/dist/main/services/views/host-dialog-port-channel.js

@@ -0,0 +1,15 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import { ViewChannel } from '../../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortChannel, } from './host-slot-port-channel.js';
+export function createHostDialogPortChannel(opts) {
+    return createHostSlotPortChannel({
+        isCurrent: opts.isCurrent,
+        channel: ViewChannel.HostDialogPort,
+        logPrefix: '[host-dialog]',
+    });
+}
+//# sourceMappingURL=host-dialog-port-channel.js.map

package/dist/main/services/views/host-dialog-session-runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a dialog-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar/sidebar's independent ref-counts.
+ */
+export declare function acquireHostDialogSessionRuntime(): void;
+export declare function releaseHostDialogSessionRuntime(): void;
+//# sourceMappingURL=host-dialog-session-runtime.d.ts.map

package/dist/main/services/views/host-dialog-session-runtime.js

@@ -0,0 +1,17 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a dialog-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar/sidebar's independent ref-counts.
+ */
+import { createHostSlotSessionRuntime } from './host-slot-session-runtime.js';
+import { hostDialogRuntimePreloadPath } from '../../utils/paths.js';
+const runtime = createHostSlotSessionRuntime(hostDialogRuntimePreloadPath);
+export function acquireHostDialogSessionRuntime() {
+    runtime.acquire();
+}
+export function releaseHostDialogSessionRuntime() {
+    runtime.release();
+}
+//# sourceMappingURL=host-dialog-session-runtime.js.map

package/dist/main/services/views/host-dialog-view.d.ts

@@ -0,0 +1,95 @@
+import type { WebContents } from 'electron';
+import type { PlacementReconciler } from './placement-reconciler.js';
+import type { ViewManagerContext } from './view-manager.js';
+import type { HostDialogMessageSubscription } from './host-dialog-port-channel.js';
+export type HostDialogAxis = 'block' | 'inline';
+/**
+ * The control object the downstream host uses to own the dialog
+ * WebContentsView. Unlike `HostToolbarControl` / `HostSidebarControl`
+ * (persistent strips), the dialog is a by-demand overlay: no extent-mode
+ * setter (it always self-sizes from its own reverse advertiser, with a
+ * conservative default while unmeasured — see below) and an explicit
+ * `show()`/`hide()`/`isVisible()` surface instead of always being present
+ * once loaded.
+ */
+export interface HostDialogControl {
+    /** Load a URL into the dialog view (lazy-creates the view). */
+    loadURL(url: string): Promise<void>;
+    /** Load a local file into the dialog view (lazy-creates the view). */
+    loadFile(path: string): Promise<void>;
+    /** The dialog view's live WebContents, or null if not yet created/destroyed. */
+    readonly webContents: WebContents | null;
+    /** Same contract as `HostToolbarControl.setPreloadPath`. */
+    setPreloadPath(path: string | null): void;
+    /**
+     * Register a host-side handler for messages the dialog PAGE sends via
+     * `window.diminaHostDialog.send(channel, payload)`. Same contract as
+     * `HostToolbarControl.onMessage`.
+     */
+    onMessage(channel: string, handler: (payload: unknown) => void): HostDialogMessageSubscription;
+    /** Same contract as `HostToolbarControl.onReady`. */
+    onReady(handler: () => void): HostDialogMessageSubscription;
+    /** Same contract as `HostToolbarControl.send`. */
+    send(channel: string, payload: unknown): boolean;
+    /**
+     * Show the dialog, centered in the main window using its self-advertised
+     * size on both axes (a conservative default for any axis not yet
+     * measured). Creates the view's placement if needed; does not (re)load
+     * content — the host must `loadURL`/`loadFile` first. Idempotent while
+     * already visible (re-centers with the latest measured extent instead of
+     * no-op, in case a resize happened while hidden).
+     */
+    show(): void;
+    /** Hide the dialog (kept alive, content preserved) without destroying the view. */
+    hide(): void;
+    /** Whether the dialog is currently shown. */
+    isVisible(): boolean;
+}
+/**
+ * The host-dialog slice of `ViewManager`'s public surface, split into its
+ * own file for the same file-length reason as sidebar's
+ * `HostSidebarViewManagerMembers` — a by-demand, dual-axis, main-centered
+ * overlay rather than a persistent strip.
+ */
+export interface HostDialogViewManagerMembers {
+    /** Return the webContents ID of the host-dialog overlay if alive, else null. */
+    getHostDialogWebContentsId(): number | null;
+    /** Reverse size-advertiser sink for either axis; re-centers while visible. */
+    reportHostDialogMeasuredExtent(axis: HostDialogAxis, extent: number): void;
+    /** Host-facing control surface for the dialog WebContentsView. */
+    readonly hostDialog: HostDialogControl;
+}
+export interface HostDialogView {
+    readonly control: HostDialogControl;
+    /**
+     * Reverse size-advertiser sink for either axis. While visible, immediately
+     * re-centers with the newly measured extent; while hidden, just retains it
+     * for the next `show()`. Non-finite / non-positive reports are dropped —
+     * same fail-closed posture as the base slots' extent validation.
+     */
+    reportMeasuredExtent(axis: HostDialogAxis, extent: number): void;
+    getHostDialogWebContentsId(): number | null;
+    /**
+     * Re-center in the main window's CURRENT content rect, e.g. after a
+     * main-window resize. No-op while hidden — the next `show()` computes
+     * fresh bounds anyway, so there is nothing to reapply.
+     */
+    reposition(): void;
+    dispose(): void;
+}
+/**
+ * Host-dialog factory — its PLACEMENT is deliberately NOT built on
+ * `createHostSlotView`. That factory models a persistent, single-axis,
+ * renderer-anchored strip (`setBaseDesired`); the dialog is a by-demand,
+ * dual-axis, main-centered overlay (`setOverlayDesired` /
+ * `deleteOverlayDesired`), closer in shape to the settings/popover/tooltip
+ * overlays in `overlay-panels-view.ts` than to the toolbar/sidebar. It still
+ * doesn't reuse `createOverlayPanel` from that file: those panels load a
+ * FIXED renderer-dir entry and push typed data, whereas the dialog loads
+ * ARBITRARY host content and needs the toolbar/sidebar's `loadURL`/`loadFile`
+ * + gated port-channel surface. The underlying WebContentsView lazy-create /
+ * liveness / load / teardown lifecycle IS shared with the base slots though
+ * — see `managed-web-contents-view.ts`.
+ */
+export declare function createHostDialogView(ctx: ViewManagerContext, reconciler: PlacementReconciler): HostDialogView;
+//# sourceMappingURL=host-dialog-view.d.ts.map

package/dist/main/services/views/host-dialog-view.js

@@ -0,0 +1,147 @@
+import { HOST_DIALOG_RUNTIME_MARKER } from '../../../shared/constants.js';
+import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
+import { acquireHostDialogSessionRuntime, releaseHostDialogSessionRuntime, } from './host-dialog-session-runtime.js';
+import { createHostDialogPortChannel } from './host-dialog-port-channel.js';
+import { createManagedWebContentsView } from './managed-web-contents-view.js';
+// Shown immediately on `show()` for whichever axis hasn't been measured yet.
+// The dialog is a by-demand overlay — there is no renderer placeholder to
+// pre-report intrinsic size the way the toolbar/sidebar's forward anchor
+// does, so the first show of a not-yet-measured axis has nothing to center
+// against. Waiting/polling for the report would mask the async race (banned
+// by this repo's timing rules); a conservative default plus a re-center the
+// moment `reportMeasuredExtent` lands is the fail-safe alternative.
+const DEFAULT_WIDTH = 480;
+const DEFAULT_HEIGHT = 320;
+/**
+ * Host-dialog factory — its PLACEMENT is deliberately NOT built on
+ * `createHostSlotView`. That factory models a persistent, single-axis,
+ * renderer-anchored strip (`setBaseDesired`); the dialog is a by-demand,
+ * dual-axis, main-centered overlay (`setOverlayDesired` /
+ * `deleteOverlayDesired`), closer in shape to the settings/popover/tooltip
+ * overlays in `overlay-panels-view.ts` than to the toolbar/sidebar. It still
+ * doesn't reuse `createOverlayPanel` from that file: those panels load a
+ * FIXED renderer-dir entry and push typed data, whereas the dialog loads
+ * ARBITRARY host content and needs the toolbar/sidebar's `loadURL`/`loadFile`
+ * + gated port-channel surface. The underlying WebContentsView lazy-create /
+ * liveness / load / teardown lifecycle IS shared with the base slots though
+ * — see `managed-web-contents-view.ts`.
+ */
+export function createHostDialogView(ctx, reconciler) {
+    const port = createHostDialogPortChannel({
+        isCurrent: (wc) => managed.liveWebContents()?.id === wc.id,
+    });
+    let visible = false;
+    let width = DEFAULT_WIDTH;
+    let height = DEFAULT_HEIGHT;
+    const managed = createManagedWebContentsView({
+        reconciler,
+        viewId: VIEW_ID.hostDialog,
+        marker: HOST_DIALOG_RUNTIME_MARKER,
+        sessionRuntime: {
+            acquire: acquireHostDialogSessionRuntime,
+            release: releaseHostDialogSessionRuntime,
+        },
+        port,
+        onBroken: () => {
+            // Same "withdraw the stale desired placement" contract as hide(): a
+            // crashed dialog must not resurrect as a blank, content-less modal the
+            // next time something calls reposition() (e.g. a window resize).
+            visible = false;
+            reconciler.deleteOverlayDesired(VIEW_ID.hostDialog);
+        },
+    });
+    function computeBounds() {
+        const [winW = 0, winH = 0] = ctx.windows.mainWindow.getContentSize();
+        // Clamp to the window so a dialog whose advertised/default size exceeds
+        // the current content area still gets valid non-negative bounds instead
+        // of spilling off-window or going negative.
+        const w = Math.min(width, Math.max(1, winW));
+        const h = Math.min(height, Math.max(1, winH));
+        return {
+            x: Math.max(0, Math.round((winW - w) / 2)),
+            y: Math.max(0, Math.round((winH - h) / 2)),
+            width: w,
+            height: h,
+        };
+    }
+    function present() {
+        reconciler.setOverlayDesired(VIEW_ID.hostDialog, {
+            viewId: VIEW_ID.hostDialog,
+            placement: { visible: true, bounds: computeBounds() },
+            layer: VIEW_LAYER.hostDialog,
+        });
+        reconciler.reconcileNow();
+    }
+    function reportMeasuredExtent(axis, extent) {
+        if (!Number.isFinite(extent) || extent <= 0)
+            return;
+        if (axis === 'inline') {
+            width = extent;
+        }
+        else {
+            height = extent;
+        }
+        if (visible)
+            present();
+    }
+    // The host swaps content into the SAME dialog view via loadURL/loadFile
+    // (e.g. re-purposing one dialog for a different prompt) — width/height are
+    // this factory's own closure state, seeded once from the DEFAULT_*
+    // constants and only ever mutated by reportMeasuredExtent, so without a
+    // reset here a fresh, unmeasured document would inherit the PREVIOUS
+    // document's size until it happens to report its own. And while the
+    // dialog is currently VISIBLE, resetting the closure state alone doesn't
+    // reach the screen — the on-screen bounds only change via `present()` —
+    // so without the same `if (visible) present()` `reportMeasuredExtent`
+    // already does, the OLD document's bounds would stay displayed
+    // indefinitely (forever, if the new document never reports at all, e.g. a
+    // fixture missing `[data-host-dialog-root]`) instead of falling back to
+    // the default the moment the swap happens.
+    function resetMeasuredExtent() {
+        width = DEFAULT_WIDTH;
+        height = DEFAULT_HEIGHT;
+        if (visible)
+            present();
+    }
+    const control = {
+        loadURL: (url) => {
+            resetMeasuredExtent();
+            return managed.loadURL(url);
+        },
+        loadFile: (filePath) => {
+            resetMeasuredExtent();
+            return managed.loadFile(filePath);
+        },
+        get webContents() {
+            return managed.liveWebContents();
+        },
+        setPreloadPath: (path) => managed.setPreloadPath(path),
+        onMessage: (channel, handler) => port.onMessage(channel, handler),
+        onReady: (handler) => port.onReady(handler),
+        send: (channel, payload) => port.send(channel, payload),
+        show() {
+            managed.ensureView();
+            visible = true;
+            present();
+        },
+        hide() {
+            visible = false;
+            reconciler.deleteOverlayDesired(VIEW_ID.hostDialog);
+            reconciler.reconcileNow();
+        },
+        isVisible: () => visible,
+    };
+    reconciler.registerView(VIEW_ID.hostDialog, {
+        getView: () => managed.getView(),
+        ensureView: () => managed.ensureView(),
+    });
+    return {
+        control,
+        reportMeasuredExtent,
+        getHostDialogWebContentsId: () => managed.liveWebContents()?.id ?? null,
+        reposition: () => { if (visible)
+            present(); },
+        dispose: () => managed.dispose(),
+    };
+}
+//# sourceMappingURL=host-dialog-view.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Sidebar-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import type { WebContents } from 'electron';
+import { type HostSlotMessageSubscription, type HostSlotPortChannel } from './host-slot-port-channel.js';
+export type HostSidebarMessageSubscription = HostSlotMessageSubscription;
+export type HostSidebarPortChannel = HostSlotPortChannel;
+export declare function createHostSidebarPortChannel(opts: {
+    /**
+     * Is `wc` still the manager's CURRENT live sidebar 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;
+}): HostSidebarPortChannel;
+//# sourceMappingURL=host-sidebar-port-channel.d.ts.map

package/dist/main/services/views/host-sidebar-port-channel.js

@@ -0,0 +1,15 @@
+/**
+ * Sidebar-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import { ViewChannel } from '../../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortChannel, } from './host-slot-port-channel.js';
+export function createHostSidebarPortChannel(opts) {
+    return createHostSlotPortChannel({
+        isCurrent: opts.isCurrent,
+        channel: ViewChannel.HostSidebarPort,
+        logPrefix: '[host-sidebar]',
+    });
+}
+//# sourceMappingURL=host-sidebar-port-channel.js.map

package/dist/main/services/views/host-sidebar-session-runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sidebar-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a sidebar-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar's independent ref-count.
+ */
+export declare function acquireHostSidebarSessionRuntime(): void;
+export declare function releaseHostSidebarSessionRuntime(): void;
+//# sourceMappingURL=host-sidebar-session-runtime.d.ts.map

package/dist/main/services/views/host-sidebar-session-runtime.js

@@ -0,0 +1,17 @@
+/**
+ * Sidebar-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a sidebar-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar's independent ref-count.
+ */
+import { createHostSlotSessionRuntime } from './host-slot-session-runtime.js';
+import { hostSidebarRuntimePreloadPath } from '../../utils/paths.js';
+const runtime = createHostSlotSessionRuntime(hostSidebarRuntimePreloadPath);
+export function acquireHostSidebarSessionRuntime() {
+    runtime.acquire();
+}
+export function releaseHostSidebarSessionRuntime() {
+    runtime.release();
+}
+//# sourceMappingURL=host-sidebar-session-runtime.js.map

package/dist/main/services/views/host-sidebar-view.d.ts

@@ -0,0 +1,59 @@
+import type { HostSlotControl } from './host-slot-view.js';
+import type { PlacementReconciler } from './placement-reconciler.js';
+import type { ViewManagerContext } from './view-manager.js';
+/**
+ * Width mode for the host-sidebar placeholder strip, mirroring
+ * `HostToolbarHeightMode` on the inline axis.
+ */
+export type HostSidebarWidthMode = 'auto' | {
+    fixed: number;
+};
+/**
+ * The control object the downstream host uses to own the sidebar
+ * WebContentsView. Derives the shared members from `HostSlotControl` — see
+ * that interface for their contract, which carries over unchanged on the
+ * inline axis — and adds only `setWidthMode` in place of the base's
+ * `setExtentMode`, mirroring `HostToolbarControl.setHeightMode`.
+ */
+export interface HostSidebarControl extends Omit<HostSlotControl, 'setExtentMode'> {
+    /**
+     * Pin or unpin the sidebar strip width. Same contract as
+     * `HostToolbarControl.setHeightMode` on the inline axis.
+     */
+    setWidthMode(mode: HostSidebarWidthMode): void;
+}
+/**
+ * The host-sidebar slice of `ViewManager`'s public surface, split into its
+ * own file (mixed in via `extends`) to keep view-manager.ts under the repo's
+ * file-length ratchet. Mirrors `hostToolbar`'s members on the inline axis;
+ * never coexists with a height-cycle dependency on settings/popover/tooltip.
+ */
+export interface HostSidebarViewManagerMembers {
+    /** Return the webContents ID of the host-sidebar overlay if alive, else null. */
+    getHostSidebarWebContentsId(): number | null;
+    /** Return the last host-sidebar width NOTIFIED to the main-window renderer. */
+    getHostSidebarWidth(): number;
+    /** Reverse size-advertiser sink for the sidebar strip's inline (width) axis. */
+    setHostSidebarWidth(extent: number): void;
+    /** Host-facing control surface for the sidebar WebContentsView. */
+    readonly hostSidebar: HostSidebarControl;
+}
+export interface HostSidebarView {
+    readonly control: HostSidebarControl;
+    setHostSidebarWidth(extent: number): void;
+    getHostSidebarWidth(): number;
+    getHostSidebarWebContentsId(): number | null;
+    dispose(): void;
+}
+/**
+ * Sidebar-specific instantiation of `createHostSlotView` (see that module for
+ * the full lazy-create / port-channel / extent-mode contract). Symmetric to
+ * `createHostToolbarView` on the inline (width) axis instead of block
+ * (height) — the slot itself is axis-agnostic (a single advertised extent
+ * number); which CSS dimension it resizes is decided entirely by the host's
+ * renderer placeholder layout, not here. The sidebar never coexists with the
+ * settings/popover/tooltip overlays, so unlike the toolbar there is no
+ * `reapplyPresentOverlays` dependency to thread through.
+ */
+export declare function createHostSidebarView(ctx: ViewManagerContext, reconciler: PlacementReconciler): HostSidebarView;
+//# sourceMappingURL=host-sidebar-view.d.ts.map

package/dist/main/services/views/host-sidebar-view.js

@@ -0,0 +1,44 @@
+import { HOST_SIDEBAR_RUNTIME_MARKER } from '../../../shared/constants.js';
+import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
+import { acquireHostSidebarSessionRuntime, releaseHostSidebarSessionRuntime, } from './host-sidebar-session-runtime.js';
+import { createHostSidebarPortChannel } from './host-sidebar-port-channel.js';
+import { createHostSlotView, deriveSlotControl } from './host-slot-view.js';
+/**
+ * Sidebar-specific instantiation of `createHostSlotView` (see that module for
+ * the full lazy-create / port-channel / extent-mode contract). Symmetric to
+ * `createHostToolbarView` on the inline (width) axis instead of block
+ * (height) — the slot itself is axis-agnostic (a single advertised extent
+ * number); which CSS dimension it resizes is decided entirely by the host's
+ * renderer placeholder layout, not here. The sidebar never coexists with the
+ * settings/popover/tooltip overlays, so unlike the toolbar there is no
+ * `reapplyPresentOverlays` dependency to thread through.
+ */
+export function createHostSidebarView(ctx, reconciler) {
+    const port = createHostSidebarPortChannel({
+        isCurrent: (wc) => slot.getWebContentsId() === wc.id,
+    });
+    const slot = createHostSlotView(reconciler, {
+        viewId: VIEW_ID.hostSidebar,
+        layer: VIEW_LAYER.hostSidebar,
+        marker: HOST_SIDEBAR_RUNTIME_MARKER,
+        sessionRuntime: {
+            acquire: acquireHostSidebarSessionRuntime,
+            release: releaseHostSidebarSessionRuntime,
+        },
+        portChannel: port,
+        setExtentModeErrorLabel: 'hostSidebar.setWidthMode',
+    }, {
+        onExtentChanged: (width) => ctx.notify.hostSidebarWidthChanged(width),
+    });
+    const control = deriveSlotControl(slot.control, {
+        setWidthMode: (mode) => slot.control.setExtentMode(mode),
+    });
+    return {
+        control,
+        setHostSidebarWidth: (extent) => slot.setExtent(extent),
+        getHostSidebarWidth: () => slot.getExtent(),
+        getHostSidebarWebContentsId: () => slot.getWebContentsId(),
+        dispose: () => slot.dispose(),
+    };
+}
+//# sourceMappingURL=host-sidebar-view.js.map