@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/shared/compile-modes.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Single source of truth for the compile-mode model: the named modes a
+ * project defines, which one is selected, and how that selection resolves
+ * into the launch parameters a compile runs with.
+ *
+ * The stored form (`CompileModes`) is WeChat DevTools' `condition.miniprogram`
+ * shape, so `project.config.json` round-trips between both tools. Everything
+ * here is pure — the storage side lives in main's `project-repository.ts`,
+ * the UI side in the compile-mode popover.
+ */
+/**
+ * The launch parameters a compile actually runs with, after resolving the
+ * selected compile mode. Derived, never the stored form — see `CompileModes`.
+ */
+export interface CompileConfig {
+    startPage: string;
+    scene: number;
+    queryParams: {
+        key: string;
+        value: string;
+    }[];
+}
+/**
+ * One named compile mode. Field names and shape mirror WeChat DevTools'
+ * `project.config.json` → `condition.miniprogram.list[]` entry so the same
+ * file round-trips between both tools; `query` is therefore the raw
+ * `k=v&k2=v2` string it stores, not parsed pairs.
+ *
+ * `launchMode` / `partialCompile` are WeChat's own fields. We neither read
+ * nor write them, but they ride along on every mode so saving from here
+ * never drops what the other tool put in the file.
+ */
+export interface CompileMode {
+    name: string;
+    pathName: string;
+    query: string;
+    /** `null` means "unset" — the resolver falls back to `DEFAULT_SCENE`. */
+    scene: number | null;
+    launchMode?: unknown;
+    partialCompile?: unknown;
+}
+/**
+ * A project's compile modes plus which one is selected. This is the stored
+ * form; the effective `CompileConfig` is resolved from it
+ * (`resolveCompileConfig` below).
+ */
+export interface CompileModes {
+    /** Index into `list`. `-1` (`NORMAL_COMPILE_INDEX`) selects 普通编译. */
+    current: number;
+    list: CompileMode[];
+}
+/**
+ * `CompileModes.current` value selecting 普通编译 — launch the app's own
+ * entry page with the default scene and no params. It is not an entry in
+ * `list`: 普通编译 is fixed and has nothing to edit, matching WeChat, where
+ * the same fixed item sits above the custom list at index -1.
+ */
+export declare const NORMAL_COMPILE_INDEX = -1;
+/**
+ * Stand-in for a custom mode the user never named. It must not read as
+ * 普通编译: a mode can legitimately have an empty name AND an empty
+ * `pathName` (its 启动页面 left on 默认为首页) while still carrying params or
+ * a scene, and calling that 普通编译 would tell the user they are running
+ * something they are not.
+ */
+export declare const UNNAMED_MODE_LABEL = "\u672A\u547D\u540D\u6A21\u5F0F";
+/**
+ * Parse a raw `k=v&k2=v2` query string into ordered pairs.
+ *
+ * Unlike `decodePageSpec` (which yields a `Record` and so silently collapses
+ * repeats), this preserves order and duplicate keys — the k/v editor shows
+ * exactly what the user typed into the raw field, including `a=1&a=2`.
+ * A bare segment with no `=` parses to an empty value.
+ */
+export declare function parseQueryString(query: string): {
+    key: string;
+    value: string;
+}[];
+/**
+ * Serialize ordered pairs back into a raw query string. Rows with an empty
+ * key are dropped — the k/v editor keeps a blank row around while the user
+ * is still typing, and a blank row is not a parameter.
+ */
+export declare function stringifyQueryParams(params: {
+    key: string;
+    value: string;
+}[]): string;
+/**
+ * Resolve the selected mode into the launch parameters. 普通编译 (and any
+ * out-of-range `current`, which a hand-edited config file can produce)
+ * resolves to an empty `startPage`; the caller substitutes the project's own
+ * entry page for it, since only the caller knows the project.
+ */
+export declare function resolveCompileConfig(modes: CompileModes): CompileConfig;
+/**
+ * The id-based model's counterpart to `resolveCompileConfig`: derives the
+ * launch parameters straight from a single already-selected mode (or the
+ * normal-compile default for `null`) without any index/list to consult.
+ */
+export declare function compileConfigFromMode(mode: CompileMode | null): CompileConfig;
+/**
+ * Text for the toolbar's compile-mode button: the selected mode's name,
+ * falling back to its start page when the user left the name blank, so an
+ * unnamed mode is still identifiable. Only `null` (nothing selected) may
+ * produce the 普通编译 label — see {@link UNNAMED_MODE_LABEL}.
+ */
+export declare function compileModeLabel(mode: CompileMode | null): string;
+/**
+ * Coerce whatever is on disk into a usable `CompileModes`. The source is a
+ * user-editable JSON file that another tool also writes, so every field is
+ * treated as untrusted: a malformed file degrades to 普通编译 rather than
+ * failing the project open.
+ */
+export declare function normalizeCompileModes(raw: unknown): CompileModes;
+/** An empty model — no custom modes, 普通编译 selected. */
+export declare function emptyCompileModes(): CompileModes;
+/**
+ * Build a mode out of resolved launch parameters. Used to migrate a legacy
+ * single compile config into the list, and by the popover when the user
+ * turns the simulator's current page into a mode.
+ */
+export declare function compileConfigToMode(config: CompileConfig, name: string): CompileMode;
+/**
+ * Whether resolved launch parameters are exactly what 普通编译 already
+ * launches, and so carry nothing worth surfacing as a named mode. An empty
+ * `startPage` means "the app's own entry page", which is what 普通编译 is;
+ * `entryPagePath` lets a caller that knows the project also recognize a config
+ * that names that page outright.
+ */
+export declare function isNormalCompile(config: CompileConfig, entryPagePath: string): boolean;
+/**
+ * Project a single legacy compile config into the mode list, as one unnamed
+ * selected mode — unless it asks for nothing 普通编译 can't already do, in
+ * which case the list stays empty rather than gaining a mode that says the
+ * same thing as the fixed entry above it.
+ *
+ * Both places that meet the older single-config form go through here: the
+ * project repository migrating `dimina-projects.json`, and the workspace
+ * adapter reading a host that only implements `getCompileConfig`. Callers that
+ * can resolve the project's entry page pass it so a config naming that page
+ * counts as 普通编译 too.
+ */
+export declare function compileConfigToModes(config: CompileConfig, entryPagePath?: string): CompileModes;
+/**
+ * Build a mode from a `pagePath?k=v&…` route string — the format
+ * `getCurrentPageRoute` reports for the simulator's visible page, which is
+ * what "以当前页面新建编译模式" starts from. Scene is left unset so the new
+ * mode launches with the default rather than inheriting whatever scene the
+ * running session happened to use.
+ */
+export declare function routeToMode(route: string, name: string): CompileMode;
+//# sourceMappingURL=compile-modes.d.ts.map

package/dist/shared/compile-modes.js

@@ -0,0 +1,237 @@
+/**
+ * Single source of truth for the compile-mode model: the named modes a
+ * project defines, which one is selected, and how that selection resolves
+ * into the launch parameters a compile runs with.
+ *
+ * The stored form (`CompileModes`) is WeChat DevTools' `condition.miniprogram`
+ * shape, so `project.config.json` round-trips between both tools. Everything
+ * here is pure — the storage side lives in main's `project-repository.ts`,
+ * the UI side in the compile-mode popover.
+ */
+import { DEFAULT_SCENE } from './constants.js';
+/**
+ * `CompileModes.current` value selecting 普通编译 — launch the app's own
+ * entry page with the default scene and no params. It is not an entry in
+ * `list`: 普通编译 is fixed and has nothing to edit, matching WeChat, where
+ * the same fixed item sits above the custom list at index -1.
+ */
+export const NORMAL_COMPILE_INDEX = -1;
+/** Label shown when no custom mode is selected. */
+const NORMAL_COMPILE_LABEL = '普通编译';
+/**
+ * Stand-in for a custom mode the user never named. It must not read as
+ * 普通编译: a mode can legitimately have an empty name AND an empty
+ * `pathName` (its 启动页面 left on 默认为首页) while still carrying params or
+ * a scene, and calling that 普通编译 would tell the user they are running
+ * something they are not.
+ */
+export const UNNAMED_MODE_LABEL = '未命名模式';
+/**
+ * Parse a raw `k=v&k2=v2` query string into ordered pairs.
+ *
+ * Unlike `decodePageSpec` (which yields a `Record` and so silently collapses
+ * repeats), this preserves order and duplicate keys — the k/v editor shows
+ * exactly what the user typed into the raw field, including `a=1&a=2`.
+ * A bare segment with no `=` parses to an empty value.
+ */
+export function parseQueryString(query) {
+    const pairs = [];
+    for (const segment of query.split('&')) {
+        if (!segment)
+            continue;
+        const eqIdx = segment.indexOf('=');
+        const rawKey = eqIdx >= 0 ? segment.slice(0, eqIdx) : segment;
+        const rawValue = eqIdx >= 0 ? segment.slice(eqIdx + 1) : '';
+        if (!rawKey)
+            continue;
+        pairs.push({ key: safeDecode(rawKey), value: safeDecode(rawValue) });
+    }
+    return pairs;
+}
+/**
+ * Serialize ordered pairs back into a raw query string. Rows with an empty
+ * key are dropped — the k/v editor keeps a blank row around while the user
+ * is still typing, and a blank row is not a parameter.
+ */
+export function stringifyQueryParams(params) {
+    return params
+        .filter((p) => p.key)
+        .map((p) => `${encodeURIComponent(p.key)}=${encodeURIComponent(p.value)}`)
+        .join('&');
+}
+/**
+ * Resolve the selected mode into the launch parameters. 普通编译 (and any
+ * out-of-range `current`, which a hand-edited config file can produce)
+ * resolves to an empty `startPage`; the caller substitutes the project's own
+ * entry page for it, since only the caller knows the project.
+ */
+export function resolveCompileConfig(modes) {
+    const { current, list } = modes;
+    const mode = Number.isInteger(current) && current >= 0 && current < list.length
+        ? list[current] ?? null
+        : null;
+    return compileConfigFromMode(mode);
+}
+/**
+ * The id-based model's counterpart to `resolveCompileConfig`: derives the
+ * launch parameters straight from a single already-selected mode (or the
+ * normal-compile default for `null`) without any index/list to consult.
+ */
+export function compileConfigFromMode(mode) {
+    if (!mode) {
+        return { startPage: '', scene: DEFAULT_SCENE, queryParams: [] };
+    }
+    return {
+        startPage: mode.pathName,
+        scene: mode.scene ?? DEFAULT_SCENE,
+        queryParams: parseQueryString(mode.query),
+    };
+}
+/**
+ * Text for the toolbar's compile-mode button: the selected mode's name,
+ * falling back to its start page when the user left the name blank, so an
+ * unnamed mode is still identifiable. Only `null` (nothing selected) may
+ * produce the 普通编译 label — see {@link UNNAMED_MODE_LABEL}.
+ */
+export function compileModeLabel(mode) {
+    if (!mode)
+        return NORMAL_COMPILE_LABEL;
+    return mode.name || mode.pathName || UNNAMED_MODE_LABEL;
+}
+/**
+ * Coerce whatever is on disk into a usable `CompileModes`. The source is a
+ * user-editable JSON file that another tool also writes, so every field is
+ * treated as untrusted: a malformed file degrades to 普通编译 rather than
+ * failing the project open.
+ */
+export function normalizeCompileModes(raw) {
+    if (!isRecord(raw))
+        return emptyCompileModes();
+    const rawCurrent = Number.isInteger(raw.current)
+        ? raw.current
+        : NORMAL_COMPILE_INDEX;
+    // Dropping a malformed entry shifts every later entry down, so the selection
+    // is remapped while the list is built. Keeping the raw index would select a
+    // DIFFERENT mode than the file did — the file says 首页, the simulator
+    // launches 购物车. A selected entry that is itself dropped falls back to
+    // 普通编译.
+    const list = [];
+    let current = NORMAL_COMPILE_INDEX;
+    if (Array.isArray(raw.list)) {
+        for (const [index, item] of raw.list.entries()) {
+            const mode = normalizeCompileMode(item);
+            if (!mode)
+                continue;
+            if (index === rawCurrent)
+                current = list.length;
+            list.push(mode);
+        }
+    }
+    return { current, list };
+}
+/** An empty model — no custom modes, 普通编译 selected. */
+export function emptyCompileModes() {
+    return { current: NORMAL_COMPILE_INDEX, list: [] };
+}
+/**
+ * Build a mode out of resolved launch parameters. Used to migrate a legacy
+ * single compile config into the list, and by the popover when the user
+ * turns the simulator's current page into a mode.
+ */
+export function compileConfigToMode(config, name) {
+    return {
+        name,
+        pathName: config.startPage,
+        query: stringifyQueryParams(config.queryParams ?? []),
+        scene: config.scene,
+    };
+}
+/**
+ * Whether resolved launch parameters are exactly what 普通编译 already
+ * launches, and so carry nothing worth surfacing as a named mode. An empty
+ * `startPage` means "the app's own entry page", which is what 普通编译 is;
+ * `entryPagePath` lets a caller that knows the project also recognize a config
+ * that names that page outright.
+ */
+export function isNormalCompile(config, entryPagePath) {
+    return (!config.startPage || config.startPage === entryPagePath)
+        && (config.scene ?? DEFAULT_SCENE) === DEFAULT_SCENE
+        && (config.queryParams?.length ?? 0) === 0;
+}
+/**
+ * Project a single legacy compile config into the mode list, as one unnamed
+ * selected mode — unless it asks for nothing 普通编译 can't already do, in
+ * which case the list stays empty rather than gaining a mode that says the
+ * same thing as the fixed entry above it.
+ *
+ * Both places that meet the older single-config form go through here: the
+ * project repository migrating `dimina-projects.json`, and the workspace
+ * adapter reading a host that only implements `getCompileConfig`. Callers that
+ * can resolve the project's entry page pass it so a config naming that page
+ * counts as 普通编译 too.
+ */
+export function compileConfigToModes(config, entryPagePath = '') {
+    if (isNormalCompile(config, entryPagePath))
+        return emptyCompileModes();
+    return { current: 0, list: [compileConfigToMode(config, '')] };
+}
+/**
+ * Build a mode from a `pagePath?k=v&…` route string — the format
+ * `getCurrentPageRoute` reports for the simulator's visible page, which is
+ * what "以当前页面新建编译模式" starts from. Scene is left unset so the new
+ * mode launches with the default rather than inheriting whatever scene the
+ * running session happened to use.
+ */
+export function routeToMode(route, name) {
+    const qIdx = route.indexOf('?');
+    return {
+        name,
+        pathName: qIdx >= 0 ? route.slice(0, qIdx) : route,
+        query: qIdx >= 0 ? route.slice(qIdx + 1) : '',
+        scene: null,
+    };
+}
+/**
+ * A mode needs a start page to mean anything, so an entry without a string
+ * `pathName` is dropped rather than kept as an unlaunchable row. Unknown
+ * fields WeChat writes are carried through untouched.
+ */
+function normalizeCompileMode(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (typeof raw.pathName !== 'string')
+        return null;
+    const scene = typeof raw.scene === 'number'
+        ? raw.scene
+        : typeof raw.scene === 'string' && raw.scene.trim() !== '' && Number.isFinite(Number(raw.scene))
+            ? Number(raw.scene)
+            : null;
+    const mode = {
+        name: typeof raw.name === 'string' ? raw.name : '',
+        pathName: raw.pathName,
+        query: typeof raw.query === 'string' ? raw.query : '',
+        scene,
+    };
+    if ('launchMode' in raw)
+        mode.launchMode = raw.launchMode;
+    if ('partialCompile' in raw)
+        mode.partialCompile = raw.partialCompile;
+    return mode;
+}
+/**
+ * `decodeURIComponent` throws on a lone `%` — which a user editing the raw
+ * query field types on the way to `%20`. Keep the literal text instead of
+ * losing the whole field to an exception.
+ */
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=compile-modes.js.map

package/dist/shared/constants.d.ts

@@ -21,4 +21,26 @@ export declare const HEADER_H = 40;
  * both guard wings are required).
  */
 export declare const HOST_TOOLBAR_RUNTIME_MARKER = "--dimina-host-toolbar";
+/**
+ * Same guard-marker contract as {@link HOST_TOOLBAR_RUNTIME_MARKER}, for the
+ * host-sidebar WebContentsView (`src/preload/runtime/host-sidebar-runtime.ts`).
+ */
+export declare const HOST_SIDEBAR_RUNTIME_MARKER = "--dimina-host-sidebar";
+/**
+ * Same guard-marker contract as {@link HOST_TOOLBAR_RUNTIME_MARKER}, for the
+ * host-dialog WebContentsView (`src/preload/runtime/host-dialog-runtime.ts`).
+ */
+export declare const HOST_DIALOG_RUNTIME_MARKER = "--dimina-host-dialog";
+/**
+ * Intrinsic width (px) of devtools' own default host-sidebar content (the
+ * project-category icon rail). Single source of truth shared by the renderer
+ * (`host-sidebar-default.tsx`, which gives its `[data-host-sidebar-root]` this
+ * exact width so the width advertiser reports it) and anything in main that
+ * needs to reason about the default rail's size. The slot is NOT left pinned
+ * at this width: main pushes it once as a seed and immediately returns the
+ * slot to 'auto' (see `createDevtoolsRuntime`), so the rail — and any
+ * downstream `loadURL`/`loadFile` content that replaces it — advertises its
+ * own width from then on, exactly like any other host-sidebar content.
+ */
+export declare const HOST_SIDEBAR_DEFAULT_WIDTH = 56;
 //# sourceMappingURL=constants.d.ts.map

package/dist/shared/constants.js

@@ -21,4 +21,26 @@ export const HEADER_H = 40;
  * both guard wings are required).
  */
 export const HOST_TOOLBAR_RUNTIME_MARKER = '--dimina-host-toolbar';
+/**
+ * Same guard-marker contract as {@link HOST_TOOLBAR_RUNTIME_MARKER}, for the
+ * host-sidebar WebContentsView (`src/preload/runtime/host-sidebar-runtime.ts`).
+ */
+export const HOST_SIDEBAR_RUNTIME_MARKER = '--dimina-host-sidebar';
+/**
+ * Same guard-marker contract as {@link HOST_TOOLBAR_RUNTIME_MARKER}, for the
+ * host-dialog WebContentsView (`src/preload/runtime/host-dialog-runtime.ts`).
+ */
+export const HOST_DIALOG_RUNTIME_MARKER = '--dimina-host-dialog';
+/**
+ * Intrinsic width (px) of devtools' own default host-sidebar content (the
+ * project-category icon rail). Single source of truth shared by the renderer
+ * (`host-sidebar-default.tsx`, which gives its `[data-host-sidebar-root]` this
+ * exact width so the width advertiser reports it) and anything in main that
+ * needs to reason about the default rail's size. The slot is NOT left pinned
+ * at this width: main pushes it once as a seed and immediately returns the
+ * slot to 'auto' (see `createDevtoolsRuntime`), so the rail — and any
+ * downstream `loadURL`/`loadFile` content that replaces it — advertises its
+ * own width from then on, exactly like any other host-sidebar content.
+ */
+export const HOST_SIDEBAR_DEFAULT_WIDTH = 56;
 //# sourceMappingURL=constants.js.map

package/dist/shared/dmb-resource-url.d.ts

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/shared/dmb-resource-url';
+//# sourceMappingURL=dmb-resource-url.d.ts.map

package/dist/shared/dmb-resource-url.js

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/shared/dmb-resource-url';
+//# sourceMappingURL=dmb-resource-url.js.map

package/dist/shared/ipc-channels-overlays.d.ts

@@ -0,0 +1,162 @@
+/**
+ * IPC channel name constants for dimina-devtools' overlay/panel
+ * WebContentsViews — layout slots (host-toolbar/host-sidebar/host-dialog),
+ * the popover, tooltip, project-create dialog and settings overlays, plus
+ * the update flow. Split out of `ipc-channels.ts` (see that file's header)
+ * once this group alone pushed it past the repo's file-length threshold —
+ * these constants share no runtime dependency on the rest of that file, so
+ * the split is a pure line-count relief valve, not a behavior change.
+ */
+export declare const ViewChannel: {
+    /**
+     * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
+     * intrinsic content height so main reserves exactly that much. Payload
+     * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
+     */
+    readonly HostToolbarAdvertiseHeight: "view:host-toolbar:advertise-height";
+    /**
+     * main → host-toolbar WCV renderer: per-load MessagePort handshake for the
+     * gated narrow channel. On every toolbar `did-finish-load` main creates a
+     * `MessageChannelMain` and transfers port2 here
+     * (`wc.postMessage(HostToolbarPort, null, [port2])`); the session-resident
+     * toolbar runtime preload receives it via `event.ports[0]` and bridges it to
+     * the page as `window.diminaHostToolbar`. Envelope both directions:
+     * `{ channel: string, payload: unknown }`.
+     */
+    readonly HostToolbarPort: "view:host-toolbar:port";
+    /**
+     * main → main-window renderer: push the reserved host-toolbar height so the
+     * renderer placeholder div resizes (closing the dynamic-height loop).
+     */
+    readonly HostToolbarHeightChanged: "view:host-toolbar:height-changed";
+    /**
+     * main ← main-window renderer (invoke): pull the last NOTIFIED toolbar
+     * height retained in main. Mount-time replay companion to
+     * `HostToolbarHeightChanged`: the push listener mounts with the project
+     * view and the toolbar's size-advertiser deduplicates (never re-reports),
+     * so a height pushed while no project view was mounted would otherwise be
+     * lost forever (cold start on the project list races it; close-project →
+     * reopen hits it deterministically). No payload; resolves a number.
+     */
+    readonly HostToolbarGetHeight: "view:host-toolbar:get-height";
+    /**
+     * Reverse size-advertiser for the host-sidebar WCV, mirroring
+     * `HostToolbarAdvertiseHeight` on the inline (width) axis instead of block.
+     * Payload `{ axis: 'inline', extent }`. fire-and-forget (send), NOT invoke.
+     */
+    readonly HostSidebarAdvertiseWidth: "view:host-sidebar:advertise-width";
+    /**
+     * main → host-sidebar WCV renderer: per-load MessagePort handshake, same
+     * contract as `HostToolbarPort` (see that entry).
+     */
+    readonly HostSidebarPort: "view:host-sidebar:port";
+    /**
+     * main → main-window renderer: push the reserved host-sidebar width so the
+     * renderer placeholder div resizes, mirroring `HostToolbarHeightChanged`.
+     */
+    readonly HostSidebarWidthChanged: "view:host-sidebar:width-changed";
+    /**
+     * main ← main-window renderer (invoke): pull the last NOTIFIED sidebar
+     * width, mirroring `HostToolbarGetHeight`'s mount-time replay role.
+     */
+    readonly HostSidebarGetWidth: "view:host-sidebar:get-width";
+    /**
+     * main → main-window renderer: push the project category (`Project.type`)
+     * selected in the host-sidebar's content — devtools' own default icon rail,
+     * or any downstream replacement that sends on the same channel. No
+     * pull/replay companion like `HostSidebarGetWidth`: the default category is
+     * a stable initial value regardless of load-order, and nothing is ever sent
+     * before the main-window renderer (and thus `ProjectListScreen`) is already
+     * mounted.
+     */
+    readonly HostSidebarCategorySelected: "view:host-sidebar:category-selected";
+    /**
+     * Reverse size-advertiser for the host-dialog WCV. Unlike the toolbar/sidebar
+     * (single-axis, `setBaseDesired`-placed strips), the dialog is a BOTH-AXES
+     * overlay positioned by `setOverlayDesired` — main centers it in the main
+     * window once it knows both dimensions. One channel carries either axis'
+     * report (`{ axis: 'block' | 'inline', extent }`); the dialog's own content
+     * advertises both from the same root (see `host-dialog-advertiser.ts`).
+     * fire-and-forget (send), NOT invoke.
+     *
+     * No `HostDialogSizeChanged` / `HostDialogGetSize` counterparts: those exist
+     * for toolbar/sidebar so a renderer-owned PLACEHOLDER can replay a size it
+     * missed. The dialog has no such placeholder — it is a main-driven overlay
+     * shown/hidden on demand (`hostDialog.show()`/`hide()`), so there is nothing
+     * in the renderer to replay a size into.
+     */
+    readonly HostDialogAdvertiseSize: "view:host-dialog:advertise-size";
+    /**
+     * main → host-dialog WCV renderer: per-load MessagePort handshake, same
+     * contract as `HostToolbarPort` (see that entry).
+     */
+    readonly HostDialogPort: "view:host-dialog:port";
+    /**
+     * Renderer → main: the window-level placement snapshot (one monotonic epoch
+     * per commit tick, one generation per renderer lifetime) that drives the view
+     * reconciler. The single source of truth for every managed native view's
+     * bounds/visibility/z-order — supersedes the per-view bounds channels above.
+     * invoke.
+     */
+    readonly PlacementSnapshot: "view:placement-snapshot";
+    /**
+     * main ← main-window renderer (invoke): allocate a fresh placement
+     * generation seed for this renderer bootstrap. See
+     * renderer-placement-generation.ts for why the seed comes from main
+     * (a wall-clock `Date.now()` seed is not guaranteed to exceed main's
+     * still-standing high-water mark across two reloads that happen faster
+     * than the clock's resolution). No payload; resolves a number.
+     */
+    readonly AllocatePlacementGeneration: "view:allocate-placement-generation";
+};
+export interface ViewBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const PopoverChannel: {
+    readonly Show: "popover:show";
+    readonly Hide: "popover:hide";
+    readonly Apply: "popover:apply";
+    readonly Closed: "popover:closed";
+    readonly Init: "popover:init";
+};
+export declare const OverlayChannel: {
+    readonly Ready: "overlay:ready";
+};
+export declare const TooltipChannel: {
+    readonly Prepare: "tooltip:prepare";
+    readonly Show: "tooltip:show";
+    readonly Hide: "tooltip:hide";
+    readonly Init: "tooltip:init";
+    readonly Measured: "tooltip:measured";
+};
+export declare const ProjectCreateChannel: {
+    readonly Show: "projectCreate:show";
+    readonly Init: "projectCreate:init";
+    readonly Submit: "projectCreate:submit";
+    readonly Cancel: "projectCreate:cancel";
+    readonly Submitted: "projectCreate:submitted";
+};
+export declare const DevicePickerChannel: {
+    readonly Show: "devicePicker:show";
+    readonly Init: "devicePicker:init";
+    readonly Select: "devicePicker:select";
+    readonly Cancel: "devicePicker:cancel";
+    readonly Selected: "devicePicker:selected";
+};
+export declare const SettingsChannel: {
+    readonly SetVisible: "settings:setVisible";
+    readonly ProjectSettingsChanged: "settings:projectSettingsChanged";
+    readonly Init: "settings:init";
+};
+export declare const UpdateChannel: {
+    readonly Check: "updates:check";
+    readonly Download: "updates:download";
+    readonly Install: "updates:install";
+    readonly DownloadProgress: "updates:downloadProgress";
+    readonly Available: "updates:available";
+    readonly Close: "updates:close";
+};
+//# sourceMappingURL=ipc-channels-overlays.d.ts.map