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

package/dist/main/services/mcp/tools/project-tools.d.ts

@@ -12,6 +12,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { CompileLogBuffer } from '../../workspace/compile-log-buffer.js';
 import type { SessionStatusStore } from '../../workspace/session-status-store.js';
+import type { McpOpenedProject } from '../opened-project.js';
 /**
  * Narrow structural slice of WorkspaceService the project tools need.
  * Structural (not a Pick of the real interface) so tests can hand in a
@@ -32,18 +33,40 @@ export interface McpProjectWorkspace {
     getProjectPath(): string;
     hasActiveSession(): boolean;
 }
-/** Everything `registerProjectTools` needs, assembled by app bootstrap. */
-export interface McpProjectHost {
+/**
+ * One project window's surfaces, resolved together. A project lives in its own
+ * window with its own workspace, status store and log buffer, so a tool call
+ * that read them one by one could mix two projects: every surface here comes
+ * from the same window at the same instant.
+ */
+export interface McpProjectTarget {
     workspace: McpProjectWorkspace;
     sessionStatus: SessionStatusStore;
     compileLogs: CompileLogBuffer;
-    /** Push the renderer to open the project (the user-click-equivalent path). */
+    /** Close this target's project window; a no-op when it has none. */
+    closeWindow(): void;
+}
+/** Everything `registerProjectTools` needs, assembled by app bootstrap. */
+export interface McpProjectHost {
+    /**
+     * The project window a call arriving now is aimed at. Taken ONCE per tool
+     * call and held for its whole lifetime: tools await compiles and teardowns,
+     * and the user is free to focus another project meanwhile — re-resolving
+     * afterwards would report one project's compile as another's, or close the
+     * window they just moved to.
+     */
+    currentProject(): McpProjectTarget;
+    /**
+     * Push the renderer to open the project (the user-click-equivalent path) and
+     * resolve with the window it landed in. A project lives in its own window
+     * with its own status store, so the caller can only await the right compile
+     * by holding that window — the window active when the call arrived is a
+     * different project.
+     */
     requestOpenInUi(project: {
         name: string;
         path: string;
-    }): void;
-    /** Push the renderer back to the project list after a close. */
-    requestNavigateBack(): void;
+    }): Promise<McpOpenedProject>;
 }
 export declare function registerProjectTools(server: McpServer, host: McpProjectHost): void;
 //# sourceMappingURL=project-tools.d.ts.map

package/dist/main/services/mcp/tools/project-tools.js

@@ -30,13 +30,14 @@ function publicPhase(snapshot, sessionActive) {
         return 'idle';
     return snapshot.phase;
 }
-function statusPayload(host) {
-    const snapshot = host.sessionStatus.get();
-    const sessionActive = host.workspace.hasActiveSession();
+/** Reads one window's own status: the pinned target, or the window an open landed in. */
+function statusPayload(source) {
+    const snapshot = source.sessionStatus.get();
+    const sessionActive = source.workspace.hasActiveSession();
     return {
         phase: publicPhase(snapshot, sessionActive),
         message: snapshot.message,
-        projectPath: host.workspace.getProjectPath(),
+        projectPath: source.workspace.getProjectPath(),
         sessionActive,
         watcherAlive: snapshot.watcherAlive,
         updatedAt: snapshot.updatedAt,
@@ -49,32 +50,37 @@ export function registerProjectTools(server, host) {
         timeoutMs: z.number().optional().default(DEFAULT_OPEN_TIMEOUT_MS)
             .describe('Max time to wait for the compile to settle'),
     }, async ({ path: rawPath, timeoutMs }) => {
+        const target = host.currentProject();
         const dir = path.resolve(rawPath);
         // Already open and settled: report instead of re-triggering a compile.
-        const current = host.sessionStatus.get();
-        if (host.workspace.getProjectPath() === dir
-            && host.workspace.hasActiveSession()
+        const current = target.sessionStatus.get();
+        if (target.workspace.getProjectPath() === dir
+            && target.workspace.hasActiveSession()
             && current.phase === 'ready') {
-            return text({ ...statusPayload(host), note: 'project already open' });
+            return text({ ...statusPayload(target), note: 'project already open' });
         }
-        const invalid = await host.workspace.validateProjectDir(dir);
+        const invalid = await target.workspace.validateProjectDir(dir);
         if (invalid)
             return errorText(invalid);
         let project;
-        if (await host.workspace.hasProject(dir)) {
-            const known = (await host.workspace.listProjects()).find((p) => p.path === dir);
+        if (await target.workspace.hasProject(dir)) {
+            const known = (await target.workspace.listProjects()).find((p) => p.path === dir);
             project = known ?? { name: path.basename(dir), path: dir };
         }
         else {
-            project = await host.workspace.addProject(dir);
+            project = await target.workspace.addProject(dir);
         }
-        // Snapshot the generation BEFORE the trigger so a previous session's
-        // settled state can never be mistaken for this open's result.
-        const afterGeneration = host.sessionStatus.get().generation;
-        host.requestOpenInUi({ name: project.name, path: project.path });
+        // The open hands back the window it landed in; that window's store is the
+        // only place this compile is reported, and its `afterGeneration` keeps a
+        // state that predates the open from being read as this open's result.
+        let opened;
         let settled;
         try {
-            settled = await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+            opened = await host.requestOpenInUi({ name: project.name, path: project.path });
+            settled = await opened.sessionStatus.waitForSettled({
+                afterGeneration: opened.afterGeneration,
+                timeoutMs,
+            });
         }
         catch (err) {
             return errorText(err instanceof Error ? err.message : String(err));
@@ -82,30 +88,36 @@ export function registerProjectTools(server, host) {
         if (settled.phase === 'error') {
             return errorText(`compile failed: ${settled.message} — call compile_logs (stream: "stderr") for details`);
         }
-        return text(statusPayload(host));
+        return text(statusPayload(opened));
     });
     server.tool('project_close', 'Close the currently open project session and return the workbench to the project list.', {}, async () => {
-        if (!host.workspace.getProjectPath() && !host.workspace.hasActiveSession()) {
+        // Held across the await: `closeProject()` yields, and a window the user
+        // focuses while it runs must not become the window this close takes down.
+        const target = host.currentProject();
+        if (!target.workspace.getProjectPath() && !target.workspace.hasActiveSession()) {
             return text({ closed: false, note: 'no project is open' });
         }
-        await host.workspace.closeProject();
-        host.requestNavigateBack();
+        await target.workspace.closeProject();
+        target.closeWindow();
         return text({ closed: true });
     });
-    server.tool('project_status', 'Query the current project compile status (phase: idle | compiling | ready | error). Includes `generation` — pass it to project_wait_ready to await the NEXT settled state.', {}, async () => text(statusPayload(host)));
+    server.tool('project_status', 'Query the current project compile status (phase: idle | compiling | ready | error). Includes `generation` — pass it to project_wait_ready to await the NEXT settled state.', {}, async () => text(statusPayload(host.currentProject())));
     server.tool('project_wait_ready', 'Wait until the compile pipeline settles (phase leaves "compiling"). Watcher rebuilds emit no "compiling" phase, so to await a rebuild after editing files pass the `generation` from a prior project_status.', {
         afterGeneration: z.number().optional()
             .describe('Only accept states recorded after this generation (from project_status). Omit to accept the current state when already settled.'),
         timeoutMs: z.number().optional().default(DEFAULT_WAIT_TIMEOUT_MS)
             .describe('Max time to wait'),
     }, async ({ afterGeneration, timeoutMs }) => {
+        // Held across the wait: the state this call reports must come from the
+        // window it was aimed at, whichever window is focused when it settles.
+        const target = host.currentProject();
         try {
-            await host.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+            await target.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
         }
         catch (err) {
             return errorText(err instanceof Error ? err.message : String(err));
         }
-        return text(statusPayload(host));
+        return text(statusPayload(target));
     });
     server.tool('compile_logs', 'Pull compile log lines incrementally. Pass the previous call\'s nextCursor as `cursor` to receive only new lines. The buffer resets on each fresh project open; watcher rebuilds append to the same timeline.', {
         cursor: z.number().optional().default(0)
@@ -114,7 +126,7 @@ export function registerProjectTools(server, host) {
         stream: z.enum(['stdout', 'stderr']).optional()
             .describe('Only lines from this stream (stderr carries compile errors)'),
     }, async ({ cursor, limit, stream }) => {
-        const read = host.compileLogs.read({ afterSeq: cursor, limit, stream });
+        const read = host.currentProject().compileLogs.read({ afterSeq: cursor, limit, stream });
         return text(read);
     });
 }

package/dist/main/services/module.d.ts

@@ -1,17 +1,25 @@
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import type { WorkbenchContext } from './workbench-context.js';
+import type { IpcContextSource } from '../utils/ipc-context-source.js';
 /**
  * A composable unit of workbench functionality.
  *
  * Built-in modules (projects, session, simulator, popover, settings) are
  * implemented as `WorkbenchModule` values.
  *
- * `setup` is invoked once during workbench bootstrap. The returned
- * Disposable is added to `ctx.registry` so module teardown is symmetric
- * with the rest of the workbench lifecycle.
+ * The two hooks differ in what they own. `setup` registers IPC once for the
+ * application and answers each message with the context the sender belongs to,
+ * so its handlers must read everything from that argument. `setupWindow` is the
+ * escape hatch for wiring that genuinely belongs to a single window — it
+ * receives that window's concrete context and may mutate it.
+ *
+ * Both returned Disposables are added to a registry so module teardown is
+ * symmetric with the rest of the workbench lifecycle.
  */
 export interface WorkbenchModule {
-    /** Set up the module against ctx. Returns a Disposable owned by ctx.registry. */
-    setup(ctx: WorkbenchContext): Disposable;
+    /** Register the module's IPC against every live window context. */
+    setup(source: IpcContextSource<WorkbenchContext>): Disposable;
+    /** Optional per-window wiring, run once for each window that opens. */
+    setupWindow?(ctx: WorkbenchContext): Disposable;
 }
 //# sourceMappingURL=module.d.ts.map

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -1,5 +1,5 @@
 import type { BrowserWindow, WebContents, WebContentsView } from 'electron';
-import type { CompileConfig } from '../../../shared/types.js';
+import type { CompileModeChange } from '../workspace/compile-mode-store.js';
 import { type EditorOpenFilePayload } from '../../../shared/ipc-channels.js';
 import type { WorkbenchSettings } from '../settings/index.js';
 import type { ProjectSettings, ProjectType } from '../projects/project-repository.js';
@@ -65,7 +65,6 @@ export interface CompileLogPayload {
  */
 export interface SettingsInitPayload {
     projectPath: string;
-    config: CompileConfig;
     projectSettings: ProjectSettings;
 }
 /**
@@ -108,8 +107,21 @@ export interface RendererNotifier {
     }): void;
     /** Tell the main renderer the compile popover has been closed. */
     popoverClosed(): void;
-    /** Ask the main renderer to relaunch the simulator with a new config. */
-    popoverRelaunch(config: CompileConfig): void;
+    /**
+     * Push the open project's `CompileModeStore` after it advanced — via the
+     * popover or any other command source. `relaunch` is true when the change
+     * affects what is currently running, so the renderer restarts the
+     * simulator with it.
+     */
+    compileModesChanged(change: CompileModeChange): void;
+    /**
+     * Push a rejected `applyCompileModeCommand` (e.g. a failed persist). The
+     * renderer surfaces this as a compile-status error without touching its
+     * mirrored `compileModes`.
+     */
+    compileModesApplyFailed(payload: {
+        message: string;
+    }): void;
     /**
      * Push the reserved host-toolbar height to the main renderer so its toolbar
      * placeholder div resizes (closes the host-toolbar dynamic-height loop).
@@ -141,6 +153,14 @@ export interface RendererNotifier {
         path: string;
         templateId: string;
     }): void;
+    /**
+     * Relay the device picked in the device-picker overlay back to the main
+     * renderer, whose simulator toolbar owns the device state — the panel only
+     * renders the list.
+     */
+    devicePickerSelected(payload: {
+        deviceName: string;
+    }): void;
     /** Initialise the currently shown compile popover overlay. */
     popoverInit(popoverView: WebContentsView, payload: unknown): void;
     /** Initialise the currently shown settings overlay (no-op if hidden). */
@@ -154,6 +174,10 @@ export interface RendererNotifier {
     }): void;
     /** Push a discovered update's info into the update overlay. */
     updateAvailable(dialogView: WebContentsView, payload: UpdateInfo): void;
+    /** Push the currently selected device into the device-picker overlay. */
+    devicePickerInit(pickerView: WebContentsView, payload: {
+        deviceName: string;
+    }): void;
     /** Initialise the standalone workbench-settings window. */
     workbenchSettingsInit(window: BrowserWindow, payload: WorkbenchSettingsInitPayload): void;
 }

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,5 +1,5 @@
 import { ProjectChannel, SessionChannel, WindowChannel, WorkbenchSettingsChannel, EditorChannel, } from '../../../shared/ipc-channels.js';
-import { SettingsChannel, PopoverChannel, TooltipChannel, ProjectCreateChannel, UpdateChannel, ViewChannel, } from '../../../shared/ipc-channels-overlays.js';
+import { SettingsChannel, PopoverChannel, TooltipChannel, ProjectCreateChannel, DevicePickerChannel, UpdateChannel, ViewChannel, } from '../../../shared/ipc-channels-overlays.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -40,8 +40,11 @@ export function createRendererNotifier(ctx) {
         popoverClosed() {
             sendToMain(PopoverChannel.Closed);
         },
-        popoverRelaunch(config) {
-            sendToMain(PopoverChannel.Relaunch, config);
+        compileModesChanged(change) {
+            sendToMain(ProjectChannel.CompileModesChanged, change);
+        },
+        compileModesApplyFailed(payload) {
+            sendToMain(ProjectChannel.CompileModesApplyFailed, payload);
         },
         hostToolbarHeightChanged(height) {
             sendToMain(ViewChannel.HostToolbarHeightChanged, height);
@@ -58,6 +61,9 @@ export function createRendererNotifier(ctx) {
         projectCreateSubmitted(payload) {
             sendToMain(ProjectCreateChannel.Submitted, payload);
         },
+        devicePickerSelected(payload) {
+            sendToMain(DevicePickerChannel.Selected, payload);
+        },
         popoverInit(popoverView, payload) {
             const wc = liveWebContents(popoverView.webContents);
             if (!wc)
@@ -82,6 +88,12 @@ export function createRendererNotifier(ctx) {
                 return;
             wc.send(UpdateChannel.Available, payload);
         },
+        devicePickerInit(pickerView, payload) {
+            const wc = liveWebContents(pickerView.webContents);
+            if (!wc)
+                return;
+            wc.send(DevicePickerChannel.Init, payload);
+        },
         settingsInit(payload) {
             const wc = liveWebContents(ctx.views.getSettingsWebContents());
             if (!wc)

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

@@ -24,6 +24,8 @@ export function createLocalProjectsProvider() {
         updateLastOpened: (dirPath) => repo.updateLastOpened(dirPath),
         getCompileConfig: (dirPath) => repo.getCompileConfig(dirPath),
         saveCompileConfig: (dirPath, cfg) => repo.saveCompileConfig(dirPath, cfg),
+        getCompileModes: (dirPath) => repo.getCompileModes(dirPath),
+        saveCompileModes: (dirPath, modes) => repo.saveCompileModes(dirPath, modes),
         saveThumbnail: (dirPath, dataUrl) => saveThumbnailFromDataUrl(dirPath, dataUrl),
         getThumbnail: (dirPath) => loadThumbnail(dirPath),
     };

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

@@ -1,4 +1,4 @@
-import type { CompileConfig, ProjectType } from '../../../shared/types.js';
+import type { CompileConfig, CompileModes, ProjectType } from '../../../shared/types.js';
 export type { ProjectType };
 export interface Project {
     name: string;
@@ -46,8 +46,38 @@ export declare function removeProject(dirPath: string): void;
  */
 export declare function updateProject(dirPath: string, patch: ProjectPatch): Project | null;
 export declare function updateLastOpened(dirPath: string): void;
+/**
+ * Read a project's compile modes from `project.config.json`'s
+ * `condition.miniprogram` — WeChat DevTools' own location and shape, so a
+ * project checked into git carries its modes to every machine, and the same
+ * directory opened in that tool shows the same list.
+ *
+ * Projects imported before compile modes existed fall back to migrating the
+ * legacy single config out of the project list file.
+ */
+export declare function getCompileModes(dirPath: string): CompileModes;
+/**
+ * Persist compile modes, merged so the rest of the target file survives —
+ * including the rest of `condition`, which for a mini-game project holds its
+ * own `condition.game` block.
+ */
+export declare function saveCompileModes(dirPath: string, modes: CompileModes): void;
+/**
+ * The launch parameters the selected mode resolves to. 普通编译 resolves to
+ * an empty start page; it is filled in here with 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).
+ */
 export declare function getCompileConfig(dirPath: string): CompileConfig;
 export declare function getProjectPages(dirPath: string): ProjectPages;
+/**
+ * @deprecated Compile modes are the stored form — call `saveCompileModes`.
+ * Kept working for embedding hosts still on the single-config setter: the
+ * config lands on the selected mode, or becomes a new selected mode when
+ * 普通编译 is selected and the config asks for more than it can express.
+ */
 export declare function saveCompileConfig(dirPath: string, config: CompileConfig): void;
 /** Read a subset of `project.config.json` exposed to the settings panel. */
 export declare function getProjectSettings(projectPath: string): ProjectSettings;

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

@@ -1,9 +1,12 @@
 import { app } from 'electron';
 import path from 'path';
 import fs from 'fs';
-import { DEFAULT_SCENE } from '../../../shared/constants.js';
+import { NORMAL_COMPILE_INDEX, compileConfigToMode, compileConfigToModes, emptyCompileModes, isNormalCompile, normalizeCompileModes, resolveCompileConfig, } from '../../../shared/compile-modes.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('projects');
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 /**
  * Merge project.config.json + project.private.config.json (private wins),
  * mirroring `dimina/fe/packages/compiler/src/env.js`'s `storeInfo`.
@@ -206,21 +209,130 @@ export function updateLastOpened(dirPath) {
         save(projects);
     }
 }
-export function getCompileConfig(dirPath) {
+/**
+ * Read a project's compile modes from `project.config.json`'s
+ * `condition.miniprogram` — WeChat DevTools' own location and shape, so a
+ * project checked into git carries its modes to every machine, and the same
+ * directory opened in that tool shows the same list.
+ *
+ * Projects imported before compile modes existed fall back to migrating the
+ * legacy single config out of the project list file.
+ */
+export function getCompileModes(dirPath) {
+    if (!dirPath)
+        return emptyCompileModes();
+    const condition = readProjectConfig(dirPath).condition;
+    const stored = isRecord(condition) && condition.miniprogram !== undefined
+        ? normalizeCompileModes(condition.miniprogram)
+        : null;
+    // A stored list with entries is the answer — it is the user's own edit. An
+    // EMPTY block is not evidence that the project has no modes: WeChat DevTools
+    // writes `"miniprogram": {"list": []}` into any project it opens, and taking
+    // that as "no modes" would drop the start page a user configured before
+    // compile modes existed.
+    if (stored && stored.list.length > 0)
+        return stored;
+    return migrateLegacyCompileConfig(dirPath) ?? stored ?? emptyCompileModes();
+}
+/**
+ * Which config file owns `condition` for this project — the one a save has to
+ * land in to be read back.
+ *
+ * `readProjectConfig` merges the private file over the public one key by key,
+ * so a private file carrying any `condition` at all (even one that only holds
+ * a mini-game block, with no `miniprogram` in it) replaces the whole merged
+ * `condition`. Writing modes to the public file in that case reports success
+ * and then reads back as if nothing had been saved.
+ *
+ * With no private `condition`, modes stay in the shared public file, where the
+ * team gets them from git.
+ */
+function compileModesConfigPath(dirPath) {
+    const privatePath = path.join(dirPath, 'project.private.config.json');
+    if (fs.existsSync(privatePath)) {
+        try {
+            const privateConfig = JSON.parse(fs.readFileSync(privatePath, 'utf-8'));
+            if (isRecord(privateConfig) && privateConfig.condition !== undefined)
+                return privatePath;
+        }
+        catch {
+            // Unparseable — readProjectConfig skips this file too, so the public one
+            // is what a read actually sees.
+        }
+    }
+    return path.join(dirPath, 'project.config.json');
+}
+/**
+ * Persist compile modes, merged so the rest of the target file survives —
+ * including the rest of `condition`, which for a mini-game project holds its
+ * own `condition.game` block.
+ */
+export function saveCompileModes(dirPath, modes) {
+    if (!dirPath)
+        return;
+    const configPath = compileModesConfigPath(dirPath);
+    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 project's
+            // build settings, which a blind rewrite would drop.
+            throw new Error(`无法保存编译模式：${configPath} 不是合法 JSON`);
+        }
+    }
+    const condition = isRecord(config.condition) ? config.condition : {};
+    fs.writeFileSync(configPath, JSON.stringify({ ...config, condition: { ...condition, miniprogram: modes } }, null, 2));
+    // The user has now said what this project's modes are, so the pre-compile-
+    // modes single config is spent. Retiring it here is what makes deleting a
+    // migrated mode stick: an empty stored list would otherwise be read as
+    // "nothing stored yet" and migrate the old config back.
+    clearLegacyCompileConfig(dirPath);
+}
+/**
+ * Projects imported before compile modes existed stored one unnamed compile
+ * config in the project list file. Surface it as a selected mode rather than
+ * silently dropping the user's start page — but only when it asks for
+ * something 普通编译 can't already do, so the common case stays an empty list.
+ * Returns null when there is nothing to migrate.
+ *
+ * Read-only: opening a project must not rewrite the user's git-tracked
+ * project.config.json. The legacy record is retired instead by the first
+ * explicit save (see `saveCompileModes`), which is also what keeps a deleted
+ * mode deleted — without that, an empty stored list would migrate again and
+ * put the mode back.
+ */
+function migrateLegacyCompileConfig(dirPath) {
+    const legacy = load().find((p) => p.path === dirPath)?.compileConfig;
+    if (!legacy)
+        return null;
+    const modes = compileConfigToModes(legacy, getProjectPages(dirPath).entryPagePath);
+    return modes.list.length > 0 ? modes : null;
+}
+/** Remove the pre-compile-modes single config from a project record. */
+function clearLegacyCompileConfig(dirPath) {
     const projects = load();
-    const project = projects.find((p) => p.path === dirPath);
-    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: [],
-    };
+    const idx = projects.findIndex((p) => p.path === dirPath);
+    if (idx < 0 || projects[idx].compileConfig === undefined)
+        return;
+    const { compileConfig: _legacy, ...rest } = projects[idx];
+    projects[idx] = rest;
+    save(projects);
+}
+/**
+ * The launch parameters the selected mode resolves to. 普通编译 resolves to
+ * an empty start page; it is filled in here with 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).
+ */
+export function getCompileConfig(dirPath) {
+    const config = resolveCompileConfig(getCompileModes(dirPath));
+    if (config.startPage)
+        return config;
+    return { ...config, startPage: getProjectPages(dirPath).entryPagePath };
 }
 export function getProjectPages(dirPath) {
     if (detectRuntimeType(dirPath) === 'minigame') {
@@ -242,13 +354,25 @@ export function getProjectPages(dirPath) {
         return { pages: [], entryPagePath: '' };
     }
 }
+/**
+ * @deprecated Compile modes are the stored form — call `saveCompileModes`.
+ * Kept working for embedding hosts still on the single-config setter: the
+ * config lands on the selected mode, or becomes a new selected mode when
+ * 普通编译 is selected and the config asks for more than it can express.
+ */
 export function saveCompileConfig(dirPath, config) {
-    const projects = load();
-    const idx = projects.findIndex((p) => p.path === dirPath);
-    if (idx >= 0) {
-        projects[idx] = { ...projects[idx], compileConfig: config };
-        save(projects);
+    const modes = getCompileModes(dirPath);
+    if (modes.current === NORMAL_COMPILE_INDEX) {
+        if (isNormalCompile(config, getProjectPages(dirPath).entryPagePath))
+            return;
+        saveCompileModes(dirPath, {
+            current: modes.list.length,
+            list: [...modes.list, compileConfigToMode(config, '')],
+        });
+        return;
     }
+    const list = modes.list.map((mode, i) => (i === modes.current ? { ...mode, ...compileConfigToMode(config, mode.name) } : mode));
+    saveCompileModes(dirPath, { ...modes, list });
 }
 /** Read a subset of `project.config.json` exposed to the settings panel. */
 export function getProjectSettings(projectPath) {

package/dist/main/services/projects/types.d.ts

@@ -4,7 +4,7 @@
  * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
  * template catalog, and the "新建项目" dialog.
  */
-import type { CompileConfig } from '../../../shared/types.js';
+import type { CompileConfig, CompileModes } from '../../../shared/types.js';
 import type { Project, ProjectPatch } from './project-repository.js';
 export type { Project, ProjectPatch };
 export type { ProjectTemplate, CreateProjectInput } from '../../../shared/types.js';
@@ -59,20 +59,43 @@ export interface ProjectsProvider {
      */
     updateLastOpened?(dirPath: string): void | Promise<void>;
     /**
-     * Read the per-project compile config.
+     * Read the per-project compile config — the launch parameters the
+     * SELECTED compile mode resolves to.
      *
-     * Default when omitted: returns `DEFAULT_COMPILE_CONFIG`
-     * (`{ startPage: '', scene: 1001, queryParams: [] }`).
+     * Default when omitted: derived from `getCompileModes`, or
+     * `DEFAULT_COMPILE_CONFIG` (`{ startPage: '', scene: 1001, queryParams: [] }`)
+     * when that is absent too. Implement this only if you can resolve the
+     * project's own entry page for 普通编译 — the derived default leaves
+     * `startPage` empty and lets the renderer substitute it.
      */
     getCompileConfig?(dirPath: string): CompileConfig | Promise<CompileConfig>;
     /**
-     * Persist the per-project compile config.
+     * @deprecated Implement `saveCompileModes` instead — the named mode list
+     * is the stored form, and this setter can only express the selected
+     * mode's parameters.
      *
-     * Default when omitted: silently no-ops — the renderer's edits will
-     * not survive a reload. Implement this if your UI exposes the compile
-     * config panel.
+     * Default when omitted: silently no-ops.
      */
     saveCompileConfig?(dirPath: string, cfg: CompileConfig): void | Promise<void>;
+    /**
+     * Read the project's compile modes and which one is selected. The stored
+     * form behind the toolbar's compile-mode dropdown; `LocalProjectsProvider`
+     * keeps it in the project's own `project.config.json` under
+     * `condition.miniprogram` (WeChat DevTools' location and shape).
+     *
+     * Default when omitted: `{ current: -1, list: [] }` — the dropdown then
+     * offers 普通编译 only.
+     */
+    getCompileModes?(dirPath: string): CompileModes | Promise<CompileModes>;
+    /**
+     * Persist the project's compile modes and selection.
+     *
+     * Default when omitted: falls back to `saveCompileConfig` with the
+     * resolved launch parameters, so a host on the older setter keeps the
+     * selection's effect but not the named list. With neither, edits do not
+     * survive a reload.
+     */
+    saveCompileModes?(dirPath: string, modes: CompileModes): void | Promise<void>;
     /**
      * Persist a captured screenshot for the given project. `imageDataUrl`
      * is a `data:image/png;base64,...` string so a remote provider can ship