@dimina-kit/devtools 0.4.0-dev.20260831134112 → 0.4.0-dev.20260907055341

package/dist/shared/compile-mode-state.js

@@ -0,0 +1,100 @@
+/**
+ * In-memory compile-mode model: selection tracks a minted id, not an index
+ * into a list. Storage (`CompileModes`, WeChat's `condition.miniprogram`
+ * shape) stays index-based so `project.config.json` keeps round-tripping —
+ * `stateFromStored`/`storedFromState` are the only two places index
+ * arithmetic happens at all. Everywhere else (in particular
+ * `applyCompileModeCommand`) only ever compares/reassigns ids, so deleting or
+ * reordering entries can never select the wrong mode by shifting a stale
+ * index onto it.
+ */
+import { NORMAL_COMPILE_INDEX, normalizeCompileModes, } from './compile-modes.js';
+/** An empty model — no custom modes, 普通编译 selected. */
+export function emptyCompileModeState() {
+    return { selectedId: null, entries: [] };
+}
+/**
+ * Build the in-memory state from whatever is on disk, minting a fresh id for
+ * each surviving entry in list order. Selection is carried across as the
+ * entry's identity (the freshly minted id), not the raw numeric `current` —
+ * `normalizeCompileModes` may have already remapped `current` when dropping
+ * a malformed earlier entry, so the id assigned here already points at the
+ * same data the stored `current` named.
+ */
+export function stateFromStored(raw, mintId) {
+    const stored = normalizeCompileModes(raw);
+    const entries = stored.list.map((mode) => ({ id: mintId(), mode }));
+    const selectedId = stored.current >= 0 && stored.current < entries.length
+        ? entries[stored.current].id
+        : null;
+    return { selectedId, entries };
+}
+/** Project the in-memory state back into the on-disk index-based shape. */
+export function storedFromState(state) {
+    const list = state.entries.map((entry) => entry.mode);
+    const current = state.selectedId === null
+        ? NORMAL_COMPILE_INDEX
+        : state.entries.findIndex((entry) => entry.id === state.selectedId);
+    return { current: current < 0 ? NORMAL_COMPILE_INDEX : current, list };
+}
+/** The selected entry's mode, or `null` for 普通编译 (including a ghost id). */
+export function selectedMode(state) {
+    if (state.selectedId === null)
+        return null;
+    return state.entries.find((entry) => entry.id === state.selectedId)?.mode ?? null;
+}
+/**
+ * Interpret one command against the current state. `relaunch` reports
+ * whether the running configuration changed, so a caller only restarts the
+ * simulator when the selected mode itself moved. A command that names an id
+ * nothing matches is a no-op and returns the SAME state reference (not a
+ * copy) so a caller can cheaply tell "nothing changed" from "changed".
+ */
+export function applyCompileModeCommand(state, command, mintId) {
+    switch (command.type) {
+        case 'select': {
+            if (command.id === null) {
+                return { state: { ...state, selectedId: null }, relaunch: true };
+            }
+            if (!state.entries.some((entry) => entry.id === command.id)) {
+                return { state, relaunch: false };
+            }
+            return { state: { ...state, selectedId: command.id }, relaunch: true };
+        }
+        case 'add': {
+            const entry = { id: mintId(), mode: command.mode };
+            return {
+                state: { selectedId: entry.id, entries: [...state.entries, entry] },
+                relaunch: true,
+            };
+        }
+        case 'update': {
+            const index = state.entries.findIndex((entry) => entry.id === command.id);
+            if (index < 0) {
+                const entry = { id: mintId(), mode: command.mode };
+                return {
+                    state: { selectedId: entry.id, entries: [...state.entries, entry] },
+                    relaunch: true,
+                };
+            }
+            const entries = [...state.entries];
+            entries[index] = { id: command.id, mode: command.mode };
+            return {
+                state: { ...state, entries },
+                relaunch: state.selectedId === command.id,
+            };
+        }
+        case 'remove': {
+            if (!state.entries.some((entry) => entry.id === command.id)) {
+                return { state, relaunch: false };
+            }
+            const entries = state.entries.filter((entry) => entry.id !== command.id);
+            const wasSelected = state.selectedId === command.id;
+            return {
+                state: { selectedId: wasSelected ? null : state.selectedId, entries },
+                relaunch: wasSelected,
+            };
+        }
+    }
+}
+//# sourceMappingURL=compile-mode-state.js.map

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/ipc-channels-overlays.d.ts

@@ -118,7 +118,7 @@ export interface ViewBounds {
 export declare const PopoverChannel: {
     readonly Show: "popover:show";
     readonly Hide: "popover:hide";
-    readonly Relaunch: "popover:relaunch";
+    readonly Apply: "popover:apply";
     readonly Closed: "popover:closed";
     readonly Init: "popover:init";
 };
@@ -139,9 +139,15 @@ export declare const ProjectCreateChannel: {
     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 ConfigChanged: "settings:configChanged";
     readonly ProjectSettingsChanged: "settings:projectSettingsChanged";
     readonly Init: "settings:init";
 };

package/dist/shared/ipc-channels-overlays.js

@@ -125,7 +125,10 @@ export const ViewChannel = {
 export const PopoverChannel = {
     Show: 'popover:show',
     Hide: 'popover:hide',
-    Relaunch: 'popover:relaunch',
+    // Popover → main → main-renderer: the edited compile modes, plus whether
+    // the change affects what is currently running (selecting a mode, or
+    // editing the selected one) and so needs a relaunch.
+    Apply: 'popover:apply',
     Closed: 'popover:closed',
     Init: 'popover:init',
 };
@@ -164,10 +167,24 @@ export const ProjectCreateChannel = {
     Cancel: 'projectCreate:cancel',
     Submitted: 'projectCreate:submitted',
 };
+// ── Device picker ────────────────────────────────────────────────────────
+//
+// A top-tier overlay WebContentsView (VIEW_LAYER.dialog), for the same reason
+// as the project-create dialog above: the simulator's own WebContentsView is
+// mounted on top of the main renderer and overlaps the centred search panel,
+// so a DOM-portaled dialog is cut in half by it. The toolbar keeps only the
+// trigger button; it asks main to show this panel with the currently selected
+// device, and main relays the picked device name back to the toolbar.
+export const DevicePickerChannel = {
+    Show: 'devicePicker:show',
+    Init: 'devicePicker:init',
+    Select: 'devicePicker:select',
+    Cancel: 'devicePicker:cancel',
+    Selected: 'devicePicker:selected',
+};
 // ── Embedded settings overlay ────────────────────────────────────────────
 export const SettingsChannel = {
     SetVisible: 'settings:setVisible',
-    ConfigChanged: 'settings:configChanged',
     ProjectSettingsChanged: 'settings:projectSettingsChanged',
     Init: 'settings:init',
 };

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

@@ -13,16 +13,8 @@ export declare const SimulatorChannel: {
     readonly Console: "simulator:console";
     readonly CurrentPage: "simulator:current-page";
 };
-/** iPhone bezel cutout family driving the device-shell notch visual. */
-export type { NativeDeviceInfo, NotchType, SafeAreaInsets, } from '@dimina-kit/electron-runtime';
+export type { DeviceOrientation, NativeDeviceInfo, SafeAreaInsets, } from '@dimina-kit/electron-runtime';
 export declare const ServiceHostChannel: {
-    /**
-     * NATIVE-HOST ONLY. Live-update the service-host window's host-env snapshot
-     * (device metrics) so subsequent `wx.getSystemInfoSync()` reflects a device
-     * change without a relaunch. The service-host preload mutates
-     * `__diminaSpawnContext.hostEnvSnapshot` in place (see `service-host/preload.cjs`).
-     */
-    readonly HostEnvUpdate: "service-host:host-env:update";
     /**
      * NATIVE-HOST ONLY. Deliver an AppData-panel edit (`{bridgeId, data}`) into
      * the service-host window. The preload resolves the page instance via
@@ -99,6 +91,9 @@ export declare const ProjectChannel: {
     readonly GetPages: "project:getPages";
     readonly GetCompileConfig: "project:getCompileConfig";
     readonly SaveCompileConfig: "project:saveCompileConfig";
+    readonly GetCompileModeState: "project:getCompileModeState";
+    readonly CompileModesChanged: "project:compileModesChanged";
+    readonly CompileModesApplyFailed: "project:compileModesApplyFailed";
     readonly Status: "project:status";
     readonly CompileLog: "project:compileLog";
     readonly CaptureThumbnail: "project:captureThumbnail";
@@ -162,7 +157,7 @@ export declare const DialogChannel: {
 export declare const WindowChannel: {
     readonly NavigateBack: "window:navigateBack";
     readonly OpenProject: "window:openProject";
-    readonly ScreenState: "window:screenState";
+    readonly OpenProjectWindow: "window:openProjectWindow";
 };
 export declare const AppChannel: {
     readonly GetBranding: "app:getBranding";

package/dist/shared/ipc-channels.js

@@ -34,13 +34,6 @@ export const SimulatorChannel = {
 };
 // ── Service host (main → hidden service-host window) ─────────────────────
 export const ServiceHostChannel = {
-    /**
-     * NATIVE-HOST ONLY. Live-update the service-host window's host-env snapshot
-     * (device metrics) so subsequent `wx.getSystemInfoSync()` reflects a device
-     * change without a relaunch. The service-host preload mutates
-     * `__diminaSpawnContext.hostEnvSnapshot` in place (see `service-host/preload.cjs`).
-     */
-    HostEnvUpdate: 'service-host:host-env:update',
     /**
      * NATIVE-HOST ONLY. Deliver an AppData-panel edit (`{bridgeId, data}`) into
      * the service-host window. The preload resolves the page instance via
@@ -138,6 +131,19 @@ export const ProjectChannel = {
     GetPages: 'project:getPages',
     GetCompileConfig: 'project:getCompileConfig',
     SaveCompileConfig: 'project:saveCompileConfig',
+    // Renderer → main invoke: the id-based in-memory snapshot for the
+    // currently open project's `CompileModeStore`. There is no
+    // `SaveCompileModes` counterpart any more — the store is main's alone to
+    // mutate, via `PopoverChannel.Apply`'s command.
+    GetCompileModeState: 'project:getCompileModeState',
+    // Main → renderer push: the open project's `CompileModeStore` advanced —
+    // via the popover, or any other command source. Carries the full
+    // `CompileModeChange` (revision, state, relaunch).
+    CompileModesChanged: 'project:compileModesChanged',
+    // Main → renderer push: an `applyCompileModeCommand` rejected (e.g. a
+    // failed persist). Carries `{ message }`; the renderer surfaces it as a
+    // compile-status error without touching `compileModes`.
+    CompileModesApplyFailed: 'project:compileModesApplyFailed',
     Status: 'project:status',
     // Main → renderer push of per-line dmcc compile logs (devkit `onLog`).
     // Dedicated channel: `project:status` keeps its one-event-per-payload
@@ -214,13 +220,10 @@ export const DialogChannel = {
 export const WindowChannel = {
     NavigateBack: 'window:navigateBack',
     OpenProject: 'window:openProject',
-    // Renderer → main: the renderer's current top-level screen ('project' when
-    // inside a project screen, 'list' on the project list / landing). The
-    // renderer pushes this on every screen change, including the moment it enters
-    // a project — BEFORE the open resolves — so a FAILED open (no session) still
-    // leaves main's mirror = 'project'. The window-close decision reads it so
-    // closing a stuck/failed project returns to the list instead of quitting.
-    ScreenState: 'window:screenState',
+    // Renderer → main invoke: open `project` in its own standalone workbench
+    // window (`entries/workbench/`), replacing the old in-place `page: 'project'`
+    // switch inside the list window's React tree.
+    OpenProjectWindow: 'window:openProjectWindow',
 };
 // ── App ──────────────────────────────────────────────────────────────────
 export const AppChannel = {