@dimina-kit/devtools 0.4.0 → 0.5.0

package/dist/main/services/network-forward/request-ids.d.ts

@@ -0,0 +1,5 @@
+/** Body caches own simulator-CDP and main-process HTTP ids, never native backend ids. */
+export declare const VIRTUAL_REQUEST_ID_PREFIX = "dimina:sim:";
+export declare const NATIVE_HTTP_REQUEST_ID_PREFIX = "dimina:http:";
+export declare const BODY_REQUEST_ID_PREFIXES: readonly ["dimina:sim:", "dimina:http:"];
+//# sourceMappingURL=request-ids.d.ts.map

package/dist/main/services/network-forward/request-ids.js

@@ -0,0 +1,5 @@
+/** Body caches own simulator-CDP and main-process HTTP ids, never native backend ids. */
+export const VIRTUAL_REQUEST_ID_PREFIX = 'dimina:sim:';
+export const NATIVE_HTTP_REQUEST_ID_PREFIX = 'dimina:http:';
+export const BODY_REQUEST_ID_PREFIXES = [VIRTUAL_REQUEST_ID_PREFIX, NATIVE_HTTP_REQUEST_ID_PREFIX];
+//# sourceMappingURL=request-ids.js.map

package/dist/main/services/network-forward/user-facing.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Judges whether a captured network request belongs on the user-facing
+ * (right-panel) DevTools Network tab, or should be hidden there — a
+ * framework/host-internal resource load, visible only in the standalone
+ * internal DevTools window's unfiltered global mirror.
+ *
+ * Single source of truth for the split (network-forward's user-facing sink
+ * and the global mirror both key off this): scheme must be one of
+ * http/https/ws/wss, AND the request's origin must not match ANY of
+ * `internalOrigins` — each is a base URL of a server this app itself runs
+ * whose own traffic is host-internal, not the developer's business traffic.
+ * There are currently two: the resource server (serves the compiled
+ * mini-app bundle) and the simulator's own static-asset server (serves
+ * `simulator.html` + its JS/CSS — a THIRD-PARTY-to-the-user-code origin the
+ * `attachSimulator` CDP session also observes, since it captures the whole
+ * simulator WebContentsView's network activity, not just the mini-app's own
+ * `wx.request` calls). `null`/`undefined` entries (a server not currently
+ * running, e.g. no project open) are skipped, not treated as a match.
+ */
+export declare function isUserFacingRequest(url: string, internalOrigins?: ReadonlyArray<string | null | undefined>): boolean;
+//# sourceMappingURL=user-facing.d.ts.map

package/dist/main/services/network-forward/user-facing.js

@@ -0,0 +1,50 @@
+/** URL schemes that can carry the mini-app author's own business traffic. */
+const USER_FACING_SCHEMES = new Set(['http:', 'https:', 'ws:', 'wss:']);
+/**
+ * Judges whether a captured network request belongs on the user-facing
+ * (right-panel) DevTools Network tab, or should be hidden there — a
+ * framework/host-internal resource load, visible only in the standalone
+ * internal DevTools window's unfiltered global mirror.
+ *
+ * Single source of truth for the split (network-forward's user-facing sink
+ * and the global mirror both key off this): scheme must be one of
+ * http/https/ws/wss, AND the request's origin must not match ANY of
+ * `internalOrigins` — each is a base URL of a server this app itself runs
+ * whose own traffic is host-internal, not the developer's business traffic.
+ * There are currently two: the resource server (serves the compiled
+ * mini-app bundle) and the simulator's own static-asset server (serves
+ * `simulator.html` + its JS/CSS — a THIRD-PARTY-to-the-user-code origin the
+ * `attachSimulator` CDP session also observes, since it captures the whole
+ * simulator WebContentsView's network activity, not just the mini-app's own
+ * `wx.request` calls). `null`/`undefined` entries (a server not currently
+ * running, e.g. no project open) are skipped, not treated as a match.
+ */
+export function isUserFacingRequest(url, internalOrigins) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        // Real CDP `Network.requestWillBeSent.request.url` is always a fully
+        // qualified URL — this only happens for hand-authored test/placeholder
+        // input. Fail OPEN (treat as user-facing): hiding a request the caller
+        // couldn't even classify risks silently swallowing real business
+        // traffic, a worse outcome than occasionally over-showing something.
+        return true;
+    }
+    if (!USER_FACING_SCHEMES.has(parsed.protocol))
+        return false;
+    for (const baseUrl of internalOrigins ?? []) {
+        if (!baseUrl)
+            continue;
+        try {
+            if (parsed.origin === new URL(baseUrl).origin)
+                return false;
+        }
+        catch {
+            // Malformed baseUrl — can't compare, so don't let it hide anything.
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=user-facing.js.map

package/dist/main/services/network-forward/websocket.d.ts

@@ -0,0 +1,36 @@
+import type { NativeWebSocketTrace } from '../../ipc/bridge-router.js';
+/** One CDP message ready for `DevToolsAPI.dispatchMessage` injection. */
+export interface SynthesizedWebSocketMessage {
+    method: string;
+    params: unknown;
+    /**
+     * The verdict `isUserFacingRequest` produced for this socket's url at
+     * `created` time, cached for the socket's whole lifetime — every later
+     * event reuses it (they carry no url of their own). The user-facing sink
+     * gates on this; the global mirror ignores it.
+     */
+    userFacing: boolean;
+}
+export interface WebSocketSynthesizerOptions {
+    /** Per-forwarder instance tag keeping virtual ids collision-free. */
+    epoch: string;
+    /**
+     * Origins the app itself serves (resource server / simulator shell), the
+     * same inputs `resolveUserFacing` feeds `isUserFacingRequest` for HTTP
+     * capture. Re-read at each `created`.
+     */
+    internalOrigins?: () => ReadonlyArray<string | null | undefined>;
+}
+export declare class WebSocketTraceSynthesizer {
+    private readonly options;
+    private readonly sockets;
+    private seq;
+    constructor(options: WebSocketSynthesizerOptions);
+    /**
+     * Map one trace event to its CDP message, or null when the event must be
+     * dropped (a non-`created` event for a socketId this synthesizer never saw
+     * created — defensive against out-of-order delivery).
+     */
+    synthesize(sessionId: string, event: NativeWebSocketTrace): SynthesizedWebSocketMessage | null;
+}
+//# sourceMappingURL=websocket.d.ts.map

package/dist/main/services/network-forward/websocket.js

@@ -0,0 +1,120 @@
+/**
+ * Synthesize Chrome DevTools Protocol `Network.webSocket*` messages from the
+ * main-process WebSocket trace stream (see electron-runtime
+ * `native-websocket/trace.ts`).
+ *
+ * Why this exists: `wx.connectSocket` sockets live on the Node `ws` transport
+ * in the MAIN process — no `webContents.debugger` can observe them — so the
+ * embedded DevTools Network tab would never show them. The trace stream gives
+ * one ordered fact per lifecycle moment; this module re-shapes each fact into
+ * the exact CDP event the DevTools front-end already renders natively
+ * (`webSocketCreated` creates the row, handshake events fill it, frames land
+ * in the Messages view, `webSocketClosed` settles it).
+ *
+ * Ordering contract this module relies on (guaranteed by the trace layer):
+ * `created` strictly precedes every other event for its socketId, and exactly
+ * one `closed` terminates each created socket. The front-end silently drops
+ * frame/closed events for an unknown requestId, so this module mirrors that
+ * discipline defensively: any non-created event for an unknown socketId is
+ * dropped rather than synthesized.
+ *
+ * Pure and self-contained (no Electron imports) so it is unit-testable.
+ */
+import { isUserFacingRequest } from './user-facing.js';
+export class WebSocketTraceSynthesizer {
+    options;
+    sockets = new Map();
+    seq = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Map one trace event to its CDP message, or null when the event must be
+     * dropped (a non-`created` event for a socketId this synthesizer never saw
+     * created — defensive against out-of-order delivery).
+     */
+    synthesize(sessionId, event) {
+        const key = `${sessionId} ${event.socketId}`;
+        if (event.type === 'created') {
+            const requestId = `dimina:ws:${this.options.epoch}:${this.seq++}`;
+            const userFacing = isUserFacingRequest(event.url, this.options.internalOrigins?.());
+            this.sockets.set(key, { requestId, userFacing });
+            return {
+                method: 'Network.webSocketCreated',
+                params: { requestId, url: event.url },
+                userFacing,
+            };
+        }
+        const state = this.sockets.get(key);
+        if (!state)
+            return null;
+        const { requestId, userFacing } = state;
+        const timestamp = event.time / 1000;
+        switch (event.type) {
+            case 'handshake-request':
+                return {
+                    method: 'Network.webSocketWillSendHandshakeRequest',
+                    params: {
+                        requestId,
+                        timestamp,
+                        wallTime: timestamp,
+                        request: { headers: event.headers },
+                    },
+                    userFacing,
+                };
+            case 'handshake-response':
+                return {
+                    method: 'Network.webSocketHandshakeResponseReceived',
+                    params: {
+                        requestId,
+                        timestamp,
+                        wallTime: timestamp,
+                        response: {
+                            status: event.status,
+                            statusText: event.statusText,
+                            headers: event.headers,
+                        },
+                    },
+                    userFacing,
+                };
+            case 'frame-sent':
+                return {
+                    method: 'Network.webSocketFrameSent',
+                    params: { requestId, timestamp, response: frame(event, true) },
+                    userFacing,
+                };
+            case 'frame-received':
+                return {
+                    method: 'Network.webSocketFrameReceived',
+                    params: { requestId, timestamp, response: frame(event, false) },
+                    userFacing,
+                };
+            case 'frame-error':
+                return {
+                    method: 'Network.webSocketFrameError',
+                    params: { requestId, timestamp, errorMessage: event.errorMessage },
+                    userFacing,
+                };
+            case 'closed':
+                // Terminal: release the id mapping so a long session can't grow it.
+                this.sockets.delete(key);
+                return {
+                    method: 'Network.webSocketClosed',
+                    params: { requestId, timestamp },
+                    userFacing,
+                };
+        }
+    }
+}
+/** CDP `Network.WebSocketFrame`: client-sent frames are masked, received are not. */
+function frame(event, mask) {
+    const result = {
+        opcode: event.opcode,
+        mask,
+        payloadData: event.payloadData,
+    };
+    if (event.base64Encoded)
+        result.base64Encoded = true;
+    return result;
+}
+//# sourceMappingURL=websocket.js.map

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

@@ -1,8 +1,9 @@
 import type { BrowserWindow, WebContents, WebContentsView } from 'electron';
-import type { CompileConfig, LaunchConfig } 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 } from '../projects/project-repository.js';
+import type { ProjectSettings, ProjectType } from '../projects/project-repository.js';
+import type { UpdateInfo } from '../../../shared/types.js';
 /**
  * Payload for the `project:status` event sent whenever compile status changes.
  */
@@ -64,7 +65,6 @@ export interface CompileLogPayload {
  */
 export interface SettingsInitPayload {
     projectPath: string;
-    config: CompileConfig;
     projectSettings: ProjectSettings;
 }
 /**
@@ -94,28 +94,90 @@ export interface RendererNotifier {
     compileLog(payload: CompileLogPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */
     windowNavigateBack(): void;
+    /**
+     * Ask the main renderer to open a project (mount the project runtime and
+     * start the compile), exactly as if the user clicked it in the list. The
+     * renderer owns the open path — the simulator only mounts when the
+     * ProjectRuntime component does — so main-side callers (MCP `project_open`)
+     * push this instead of calling `workspace.openProject` directly.
+     */
+    windowOpenProject(payload: {
+        name: string;
+        path: string;
+    }): 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;
-    /** Ask the main renderer to switch to a launch config (or null for normal). */
-    popoverSwitchLaunchConfig(id: string | null): void;
-    /** Ask the main renderer to update its launch configs list. */
-    popoverUpdateLaunchConfigs(configs: LaunchConfig[]): 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).
      */
     hostToolbarHeightChanged(height: number): void;
+    /**
+     * Push the reserved host-sidebar width to the main renderer so its sidebar
+     * placeholder div resizes, mirroring `hostToolbarHeightChanged` on the
+     * inline axis.
+     */
+    hostSidebarWidthChanged(width: number): void;
+    /**
+     * Push the project category selected in the host-sidebar's content to the
+     * main renderer so `ProjectListScreen` filters `ProjectList` accordingly.
+     */
+    hostSidebarCategorySelected(category: ProjectType): void;
     /**
      * Ask the main renderer's Monaco editor to open a project file at a position.
      * Drives the "click a console file link → open in editor" pipeline.
      */
     editorOpenFile(payload: EditorOpenFilePayload): void;
+    /**
+     * Relay a project-create-dialog submission from the overlay panel back to
+     * the main renderer, which owns the scaffold flow (createProject + list
+     * refresh) — the panel only collects the form and hands it off.
+     */
+    projectCreateSubmitted(payload: {
+        name: string;
+        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). */
     settingsInit(payload: SettingsInitPayload): void;
+    /** Push the label text (+ anchor) into the tooltip overlay's own renderer. */
+    tooltipInit(tooltipView: WebContentsView, payload: unknown): void;
+    /** Push the template catalog + base-dir defaults into the project-create overlay. */
+    projectCreateInit(dialogView: WebContentsView, payload: {
+        templates: unknown[];
+        defaultBaseDir: string;
+    }): 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,4 +1,5 @@
-import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, SessionChannel, WindowChannel, WorkbenchSettingsChannel, EditorChannel, } from '../../../shared/ipc-channels.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)
@@ -33,30 +34,66 @@ export function createRendererNotifier(ctx) {
         windowNavigateBack() {
             sendToMain(WindowChannel.NavigateBack);
         },
+        windowOpenProject(payload) {
+            sendToMain(WindowChannel.OpenProject, payload);
+        },
         popoverClosed() {
             sendToMain(PopoverChannel.Closed);
         },
-        popoverRelaunch(config) {
-            sendToMain(PopoverChannel.Relaunch, config);
-        },
-        popoverSwitchLaunchConfig(id) {
-            sendToMain(PopoverChannel.SwitchLaunchConfig, id);
+        compileModesChanged(change) {
+            sendToMain(ProjectChannel.CompileModesChanged, change);
         },
-        popoverUpdateLaunchConfigs(configs) {
-            sendToMain(PopoverChannel.UpdateLaunchConfigs, configs);
+        compileModesApplyFailed(payload) {
+            sendToMain(ProjectChannel.CompileModesApplyFailed, payload);
         },
         hostToolbarHeightChanged(height) {
             sendToMain(ViewChannel.HostToolbarHeightChanged, height);
         },
+        hostSidebarWidthChanged(width) {
+            sendToMain(ViewChannel.HostSidebarWidthChanged, width);
+        },
+        hostSidebarCategorySelected(category) {
+            sendToMain(ViewChannel.HostSidebarCategorySelected, category);
+        },
         editorOpenFile(payload) {
             sendToMain(EditorChannel.OpenFile, payload);
         },
+        projectCreateSubmitted(payload) {
+            sendToMain(ProjectCreateChannel.Submitted, payload);
+        },
+        devicePickerSelected(payload) {
+            sendToMain(DevicePickerChannel.Selected, payload);
+        },
         popoverInit(popoverView, payload) {
             const wc = liveWebContents(popoverView.webContents);
             if (!wc)
                 return;
             wc.send(PopoverChannel.Init, payload);
         },
+        tooltipInit(tooltipView, payload) {
+            const wc = liveWebContents(tooltipView.webContents);
+            if (!wc)
+                return;
+            wc.send(TooltipChannel.Init, payload);
+        },
+        projectCreateInit(dialogView, payload) {
+            const wc = liveWebContents(dialogView.webContents);
+            if (!wc)
+                return;
+            wc.send(ProjectCreateChannel.Init, payload);
+        },
+        updateAvailable(dialogView, payload) {
+            const wc = liveWebContents(dialogView.webContents);
+            if (!wc)
+                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/create-project-service.js

@@ -8,7 +8,8 @@
  *  3. copies the template `source` directory into `input.path`, or invokes
  *     `template.generate(input.path, { name })` for programmatic templates.
  *  4. rewrites `<input.path>/project.config.json`'s `projectname` to
- *     `input.name`.
+ *     `encodeURIComponent(input.name)` — same encoding project-repository's
+ *     `readProjectName`/`writeProjectName` use for the edit path.
  *  5. registers the project with `ctx.projectsProvider.addProject(input.path)`
  *     and returns the resulting Project.
  */
@@ -63,9 +64,16 @@ async function materializeTemplate(target, template, name) {
     if (!fs.existsSync(template.source.path)) {
         throw new Error(`Template source missing on disk: ${template.source.path}`);
     }
-    // `recursive: true` makes cpSync mirror the entire tree (files,
-    // subdirs, symlinks). `force: true` mirrors over an empty target.
-    fs.cpSync(template.source.path, target, {
+    // `recursive: true` makes cp mirror the entire tree (files, subdirs,
+    // symlinks). `force: true` mirrors over an empty target. `fs.promises.cp`
+    // (not the sync `fs.cpSync`) deliberately: cpSync's no-filter directory
+    // walk takes Node's native `cpSyncCopyDir` fast path, whose internal
+    // filesystem calls can `abort()` the whole process on certain errors
+    // (long/restricted/non-ASCII paths — nodejs/node#63970) instead of
+    // throwing a catchable JS exception. The async `cp` walks in pure JS and
+    // turns the same failures into a normal rejection this function already
+    // propagates to its IPC-boundary try/catch.
+    await fs.promises.cp(template.source.path, target, {
         recursive: true,
         force: true,
     });
@@ -74,6 +82,12 @@ async function materializeTemplate(target, template, name) {
  * Rewrite `<target>/project.config.json`'s `projectname` (best-effort: create
  * the file if the template didn't ship one — gives the user a working
  * starting point even for tiny generators).
+ *
+ * Encodes with `encodeURIComponent`, the same convention project-repository's
+ * `readProjectName`/`writeProjectName` use (aligned with WeChat DevTools:
+ * non-ASCII names go through URL encoding). Writing the raw name here would
+ * make this the one path that disagrees with the rename path, so a name with
+ * `%` or non-ASCII characters would come back different after an edit.
  */
 function writeProjectConfig(target, name) {
     const cfgPath = path.join(target, 'project.config.json');
@@ -86,7 +100,7 @@ function writeProjectConfig(target, name) {
             cfg = {};
         }
     }
-    cfg.projectname = name;
+    cfg.projectname = encodeURIComponent(name);
     fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
 }
 export async function createProject(input, ctx) {

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

@@ -14,16 +14,20 @@ 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),
         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),
-        getLaunchConfigs: (dirPath) => repo.getLaunchConfigs(dirPath),
-        saveLaunchConfigs: (dirPath, configs) => repo.saveLaunchConfigs(dirPath, configs),
-        getActiveLaunchConfigId: (dirPath) => repo.getActiveLaunchConfigId(dirPath),
-        saveActiveLaunchConfigId: (dirPath, id) => repo.saveActiveLaunchConfigId(dirPath, id),
     };
 }
 //# sourceMappingURL=local-provider.js.map

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

@@ -1,11 +1,28 @@
-import type { CompileConfig, LaunchConfig } from '../../../shared/types.js';
+import type { CompileConfig, CompileModes, ProjectType } from '../../../shared/types.js';
+export type { ProjectType };
 export interface Project {
     name: string;
     path: string;
     lastOpened?: string | null;
     compileConfig?: CompileConfig;
-    launchConfigs?: LaunchConfig[];
-    activeLaunchConfigId?: string | null;
+    /** 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[];
@@ -19,16 +36,51 @@ 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;
+/**
+ * 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;
-export declare function getLaunchConfigs(dirPath: string): LaunchConfig[];
-export declare function saveLaunchConfigs(dirPath: string, configs: LaunchConfig[]): void;
-export declare function getActiveLaunchConfigId(dirPath: string): string | null;
-export declare function saveActiveLaunchConfigId(dirPath: string, id: string | null): void;
 /** Persist a partial patch into the `setting` block of `project.config.json`. */
 export declare function updateProjectSettings(projectPath: string, patch: Partial<ProjectSettings>): void;
 //# sourceMappingURL=project-repository.d.ts.map