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

package/dist/main/services/projects/project-repository.js

@@ -4,6 +4,44 @@ import fs from 'fs';
 import { DEFAULT_SCENE } from '../../../shared/constants.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('projects');
+/**
+ * Merge project.config.json + project.private.config.json (private wins),
+ * mirroring `dimina/fe/packages/compiler/src/env.js`'s `storeInfo`.
+ */
+function readProjectConfig(dirPath) {
+    let merged = {};
+    for (const fileName of ['project.config.json', 'project.private.config.json']) {
+        const configPath = path.join(dirPath, fileName);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            merged = { ...merged, ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
+        }
+        catch (err) {
+            log.warn(`Failed to parse ${configPath}`, err);
+        }
+    }
+    return merged;
+}
+/**
+ * Mirrors `dimina/fe/packages/compiler/src/env.js`'s `detectRuntimeType` —
+ * an explicit `compileType` wins, else a mini-game is inferred from
+ * game.json + game.js/.ts with no app.json present.
+ */
+function detectRuntimeType(dirPath) {
+    const compileType = readProjectConfig(dirPath).compileType;
+    if (compileType === 'game')
+        return 'minigame';
+    if (compileType === 'miniprogram')
+        return 'miniprogram';
+    const hasMiniProgramConfig = fs.existsSync(path.join(dirPath, 'app.json'));
+    const hasMiniGameConfig = fs.existsSync(path.join(dirPath, 'game.json'));
+    const hasMiniGameEntry = ['game.js', 'game.ts']
+        .some((fileName) => fs.existsSync(path.join(dirPath, fileName)));
+    if (!hasMiniProgramConfig && hasMiniGameConfig && hasMiniGameEntry)
+        return 'minigame';
+    return 'miniprogram';
+}
 function getProjectsFile() {
     return path.join(app.getPath('userData'), 'dimina-projects.json');
 }
@@ -28,6 +66,12 @@ export function validateProjectDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
         return `小程序目录不存在：${dirPath}`;
     }
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        if (!fs.existsSync(path.join(dirPath, 'game.json'))) {
+            return '该目录缺少 game.json，请选择包含小游戏源码的目录';
+        }
+        return null;
+    }
     if (!fs.existsSync(path.join(dirPath, 'app.json'))) {
         const configPath = path.join(dirPath, 'project.config.json');
         if (fs.existsSync(configPath)) {
@@ -63,10 +107,11 @@ export function addProject(dirPath) {
     catch (err) {
         log.warn('Failed to read project name from config', err);
     }
-    const project = { name, path: dirPath, lastOpened: null };
+    const type = detectRuntimeType(dirPath);
+    const project = { name, path: dirPath, lastOpened: null, type };
     const idx = projects.findIndex((p) => p.path === dirPath);
     if (idx >= 0) {
-        projects[idx] = { ...projects[idx], name };
+        projects[idx] = { ...projects[idx], name, type };
     }
     else {
         projects.unshift(project);
@@ -88,13 +133,26 @@ export function updateLastOpened(dirPath) {
 export function getCompileConfig(dirPath) {
     const projects = load();
     const project = projects.find((p) => p.path === dirPath);
-    return (project?.compileConfig ?? {
-        startPage: '',
+    if (project?.compileConfig)
+        return project.compileConfig;
+    // Default startPage to the project's real entry page (mirrors
+    // getProjectPages: 'game' for mini-games, app.json's entryPagePath for
+    // mini-programs) rather than a mini-program-only literal — the simulator
+    // URL builders' own 'pages/index/index' fallback only fires when this is
+    // still empty (unreadable/malformed manifest).
+    return {
+        startPage: getProjectPages(dirPath).entryPagePath,
         scene: DEFAULT_SCENE,
         queryParams: [],
-    });
+    };
 }
 export function getProjectPages(dirPath) {
+    if (detectRuntimeType(dirPath) === 'minigame') {
+        // Mini-games have no page router — the compiler always emits a single
+        // synthetic 'game' entry (dimina/fe/packages/compiler/src/env.js
+        // storeAppConfig), mirrored here rather than reading a nonexistent app.json.
+        return { pages: ['game'], entryPagePath: 'game' };
+    }
     const appJsonPath = path.join(dirPath, 'app.json');
     try {
         const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));

package/dist/main/services/update/update-manager.d.ts

@@ -1,9 +1,13 @@
-import { BrowserWindow } from 'electron';
 import type { UpdateChecker, UpdateInfo } from '../../../shared/types.js';
 import { type SenderPolicy } from '../../utils/ipc-registry.js';
 export interface UpdateManagerOptions {
     checker: UpdateChecker;
-    mainWindow: BrowserWindow;
+    /** Show the update-available overlay panel, fed the discovered update's info. */
+    showUpdatePanel: (info: UpdateInfo) => void;
+    /** Forward a download-progress tick into the (already-shown) update overlay. */
+    notifyDownloadProgress: (percent: number) => void;
+    /** Hide the update overlay panel — the renderer's close (any path) forwards here. */
+    hideUpdatePanel: () => void;
     /** Check interval in milliseconds. Default: 1 hour */
     checkInterval?: number;
     /** Delay before the first check after startup in ms. Default: 5000 */
@@ -20,7 +24,9 @@ export interface UpdateManagerOptions {
 }
 export declare class UpdateManager {
     private checker;
-    private mainWindow;
+    private showUpdatePanel;
+    private notifyDownloadProgress;
+    private hideUpdatePanel;
     private getCurrentVersion;
     private latestUpdate;
     private downloadedPath;
@@ -37,6 +43,14 @@ export declare class UpdateManager {
     private timer;
     private initialTimer;
     private ipc;
+    /**
+     * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+     * in-flight `checkAndNotify()` invocation (already past its `await
+     * this.check()`) has no timer left to cancel it, and would otherwise call
+     * `showUpdatePanel` after dispose has torn down the overlay panel that
+     * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+     */
+    private disposed;
     constructor(opts: UpdateManagerOptions);
     private registerIpc;
     check(): Promise<{

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

@@ -1,9 +1,11 @@
 import { app, shell } from 'electron';
-import { UpdateChannel } from '../../../shared/ipc-channels.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
 export class UpdateManager {
     checker;
-    mainWindow;
+    showUpdatePanel;
+    notifyDownloadProgress;
+    hideUpdatePanel;
     getCurrentVersion;
     latestUpdate = null;
     downloadedPath = null;
@@ -20,9 +22,19 @@ export class UpdateManager {
     timer = null;
     initialTimer = null;
     ipc;
+    /**
+     * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+     * in-flight `checkAndNotify()` invocation (already past its `await
+     * this.check()`) has no timer left to cancel it, and would otherwise call
+     * `showUpdatePanel` after dispose has torn down the overlay panel that
+     * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+     */
+    disposed = false;
     constructor(opts) {
         this.checker = opts.checker;
-        this.mainWindow = opts.mainWindow;
+        this.showUpdatePanel = opts.showUpdatePanel;
+        this.notifyDownloadProgress = opts.notifyDownloadProgress;
+        this.hideUpdatePanel = opts.hideUpdatePanel;
         this.getCurrentVersion = opts.getCurrentVersion ?? (() => app.getVersion());
         this.ipc = new IpcRegistry(opts.senderPolicy);
         this.registerIpc();
@@ -32,7 +44,8 @@ export class UpdateManager {
         this.ipc
             .handle(UpdateChannel.Check, async () => this.check())
             .handle(UpdateChannel.Download, async () => this.download())
-            .handle(UpdateChannel.Install, async () => this.install());
+            .handle(UpdateChannel.Install, async () => this.install())
+            .on(UpdateChannel.Close, () => this.hideUpdatePanel());
     }
     async check() {
         try {
@@ -69,7 +82,7 @@ export class UpdateManager {
         }
         try {
             const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-                this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
+                this.notifyDownloadProgress(percent);
             });
             this.downloadedPath = filePath;
             return { success: true, filePath };
@@ -104,6 +117,7 @@ export class UpdateManager {
      * the timer clears + handler removals are scheduled synchronously.
      */
     dispose() {
+        this.disposed = true;
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
@@ -120,12 +134,17 @@ export class UpdateManager {
     }
     async checkAndNotify() {
         const result = await this.check();
+        // dispose() only cancels the timers that SCHEDULE future ticks — a tick
+        // already in flight (past this await) has nothing left to cancel it, and
+        // must not call into a torn-down panel/registry after the fact.
+        if (this.disposed)
+            return;
         if (!result.hasUpdate || !result.info)
             return;
         if (this.hasNotified)
             return;
         this.hasNotified = true;
-        this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
+        this.showUpdatePanel(result.info);
     }
 }
 //# sourceMappingURL=update-manager.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