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

package/dist/main/services/projects/local-provider.js

@@ -14,6 +14,12 @@ export function createLocalProjectsProvider() {
         listProjects: () => repo.listProjects(),
         addProject: (dirPath) => repo.addProject(dirPath),
         removeProject: (dirPath) => repo.removeProject(dirPath),
+        updateProject: (dirPath, patch) => {
+            const updated = repo.updateProject(dirPath, patch);
+            if (!updated)
+                throw new Error(`No such project: ${dirPath}`);
+            return updated;
+        },
         validateProjectDir: (dirPath) => repo.validateProjectDir(dirPath),
         updateLastOpened: (dirPath) => repo.updateLastOpened(dirPath),
         getCompileConfig: (dirPath) => repo.getCompileConfig(dirPath),

package/dist/main/services/projects/project-repository.d.ts

@@ -1,9 +1,28 @@
-import type { CompileConfig } from '../../../shared/types.js';
+import type { CompileConfig, ProjectType } from '../../../shared/types.js';
+export type { ProjectType };
 export interface Project {
     name: string;
     path: string;
     lastOpened?: string | null;
     compileConfig?: CompileConfig;
+    /** Absent on projects added before mini-game support — treat as 'miniprogram'. */
+    type?: ProjectType;
+    /**
+     * User-supplied icon for the project card. Absent means the card falls back
+     * to the first character of `name`.
+     */
+    iconUrl?: string;
+}
+/**
+ * The subset of a project record the user may edit after import. `path` is the
+ * record's identity (it keys every other per-project store — compile config,
+ * thumbnail, watcher) and is deliberately not patchable: pointing an existing
+ * record at another directory is an import, not an edit.
+ */
+export interface ProjectPatch {
+    name?: string;
+    /** Empty string clears the icon and restores the name-initial fallback. */
+    iconUrl?: string;
 }
 export interface ProjectPages {
     pages: string[];
@@ -17,6 +36,15 @@ export declare function validateProjectDir(dirPath: string): string | null;
 export declare function hasProject(dirPath: string): boolean;
 export declare function addProject(dirPath: string): Project;
 export declare function removeProject(dirPath: string): void;
+/**
+ * Apply a user edit to the record at `dirPath`. Returns the updated record, or
+ * `null` when no record matches — callers decide whether a missing project is
+ * an error (the IPC path) or a no-op.
+ *
+ * A name change is written through to the project's own config (see
+ * `writeProjectName`); the icon lives only in our list.
+ */
+export declare function updateProject(dirPath: string, patch: ProjectPatch): Project | null;
 export declare function updateLastOpened(dirPath: string): void;
 export declare function getCompileConfig(dirPath: string): CompileConfig;
 export declare function getProjectPages(dirPath: string): ProjectPages;

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

@@ -4,6 +4,92 @@ 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;
+}
+/**
+ * The project's display name as the project itself carries it.
+ *
+ * `projectname` lives in the merged config with the private file winning, and
+ * is URL-encoded when it leaves ASCII — WeChat DevTools 36.6.0 writes
+ * `"projectname": "%E6%BD%AE%E7%8E%A9%E6%97%8F"` and its own project list only
+ * mirrors that value. ASCII names encode to themselves, so plain values that
+ * were written by hand round-trip unchanged.
+ *
+ * Returns null when the config carries no usable name, leaving the caller to
+ * fall back to the directory name.
+ */
+function readProjectName(dirPath) {
+    const raw = readProjectConfig(dirPath).projectname;
+    if (typeof raw !== 'string' || !raw.trim())
+        return null;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        // A literal '%' that isn't a valid escape — keep the author's text.
+        return raw;
+    }
+}
+/**
+ * Persist the display name into `project.private.config.json`, the per-
+ * developer half of the project config (WeChat DevTools writes the name there
+ * too, leaving the shared `project.config.json` alone).
+ *
+ * This is what makes the config — not our list file — the single owner of the
+ * name: `addProject` re-reads it, so re-importing a directory restores the
+ * user's rename instead of resetting it.
+ */
+function writeProjectName(dirPath, name) {
+    const configPath = path.join(dirPath, 'project.private.config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // Refuse rather than overwrite: this file also holds the user's IDE
+            // settings and compile conditions, which a blind rewrite would drop.
+            throw new Error(`无法重命名：${configPath} 不是合法 JSON`);
+        }
+    }
+    fs.writeFileSync(configPath, JSON.stringify({ ...config, projectname: encodeURIComponent(name) }, null, 2));
+}
+/**
+ * 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 +114,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)) {
@@ -51,22 +143,14 @@ export function hasProject(dirPath) {
 }
 export function addProject(dirPath) {
     const projects = load();
-    let name = path.basename(dirPath);
-    try {
-        const configPath = path.join(dirPath, 'project.config.json');
-        if (fs.existsSync(configPath)) {
-            const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-            if (cfg.projectname)
-                name = cfg.projectname;
-        }
-    }
-    catch (err) {
-        log.warn('Failed to read project name from config', err);
-    }
-    const project = { name, path: dirPath, lastOpened: null };
+    // The config is the name's owner, so re-adding a directory picks up a rename
+    // the user made here rather than reverting it.
+    const name = readProjectName(dirPath) ?? path.basename(dirPath);
+    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);
@@ -77,6 +161,43 @@ export function addProject(dirPath) {
 export function removeProject(dirPath) {
     save(load().filter((p) => p.path !== dirPath));
 }
+/**
+ * Apply a user edit to the record at `dirPath`. Returns the updated record, or
+ * `null` when no record matches — callers decide whether a missing project is
+ * an error (the IPC path) or a no-op.
+ *
+ * A name change is written through to the project's own config (see
+ * `writeProjectName`); the icon lives only in our list.
+ */
+export function updateProject(dirPath, patch) {
+    const projects = load();
+    const idx = projects.findIndex((p) => p.path === dirPath);
+    if (idx < 0)
+        return null;
+    const next = { ...projects[idx] };
+    if (patch.name !== undefined) {
+        const name = patch.name.trim();
+        if (!name)
+            throw new Error('Project name cannot be empty');
+        next.name = name;
+    }
+    if (patch.iconUrl !== undefined) {
+        const iconUrl = patch.iconUrl.trim();
+        if (iconUrl)
+            next.iconUrl = iconUrl;
+        else
+            delete next.iconUrl;
+    }
+    // The config write comes first and is allowed to throw: a rename that only
+    // reached our list would look applied until the next re-import silently
+    // reverted it. The icon has no counterpart in the project config — it is
+    // ours alone — so it never touches the project directory.
+    if (next.name !== projects[idx].name)
+        writeProjectName(dirPath, next.name);
+    projects[idx] = next;
+    save(projects);
+    return next;
+}
 export function updateLastOpened(dirPath) {
     const projects = load();
     const idx = projects.findIndex((p) => p.path === dirPath);
@@ -88,13 +209,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/projects/types.d.ts

@@ -5,8 +5,8 @@
  * template catalog, and the "新建项目" dialog.
  */
 import type { CompileConfig } from '../../../shared/types.js';
-import type { Project } from './project-repository.js';
-export type { Project };
+import type { Project, ProjectPatch } from './project-repository.js';
+export type { Project, ProjectPatch };
 export type { ProjectTemplate, CreateProjectInput } from '../../../shared/types.js';
 /**
  * Default compile config returned by WorkspaceService when the injected
@@ -40,6 +40,17 @@ export interface ProjectsProvider {
     validateProjectDir?(dirPath: string): string | null | Promise<string | null>;
     addProject(dirPath: string): Project | Promise<Project>;
     removeProject(dirPath: string): void | Promise<void>;
+    /**
+     * Apply a user edit (name / icon) to an existing record. `dirPath` is the
+     * record's identity, so it is never part of the patch — see `ProjectPatch`.
+     *
+     * Default when omitted: throws, and the renderer shows that error in the
+     * edit dialog. A silent no-op would report success (dialog closes, list
+     * reloads) while discarding the user's input, since the caller has no way
+     * to tell "saved" apart from "provider doesn't support this". Implement
+     * this if your UI exposes the project-edit dialog.
+     */
+    updateProject?(dirPath: string, patch: ProjectPatch): Project | Promise<Project>;
     /**
      * Record that the user just opened a project (drives "recent" ordering).
      *

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