@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522085907

package/dist/main/services/views/view-manager.js

@@ -1,5 +1,7 @@
 import { WebContentsView, webContents } from 'electron';
 import path from 'path';
+import { mainPreloadPath } from '../../utils/paths.js';
+import { applyNavigationHardening } from '../../windows/navigation-hardening.js';
 import * as layout from '../layout/index.js';
 import { getDefaultTab } from '../workbench-context.js';
 /**
@@ -22,9 +24,9 @@ export function createViewManager(ctx) {
     function destroyViewInternal(view) {
         if (!view)
             return;
-        if (!ctx.mainWindow.isDestroyed()) {
+        if (!ctx.windows.mainWindow.isDestroyed()) {
             try {
-                ctx.mainWindow.contentView.removeChildView(view);
+                ctx.windows.mainWindow.contentView.removeChildView(view);
             }
             catch { /* already removed */ }
         }
@@ -36,21 +38,21 @@ export function createViewManager(ctx) {
         catch { /* ignore */ }
     }
     function applySimulatorBounds(simWidth) {
-        if (!simulatorView || ctx.mainWindow.isDestroyed())
+        if (!simulatorView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         simulatorView.setBounds(layout.computeSimulatorBounds(w, h, simWidth));
     }
     function applySettingsBounds() {
-        if (!settingsView || ctx.mainWindow.isDestroyed())
+        if (!settingsView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         settingsView.setBounds(layout.computeSettingsBounds(w, h));
     }
     function applyPopoverBounds() {
-        if (!popoverView || ctx.mainWindow.isDestroyed())
+        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
             return;
-        const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
         popoverView.setBounds(layout.computePopoverBounds(w, h));
     }
     // ── ViewManager methods ─────────────────────────────────────────────────
@@ -103,7 +105,7 @@ export function createViewManager(ctx) {
       `).catch(() => { });
         });
         if (getDefaultTab(ctx) === 'simulator') {
-            ctx.mainWindow.contentView.addChildView(simulatorView);
+            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
             simulatorViewAdded = true;
             applySimulatorBounds(simWidth);
         }
@@ -124,7 +126,7 @@ export function createViewManager(ctx) {
         if (!simulatorView)
             return;
         if (!simulatorViewAdded) {
-            ctx.mainWindow.contentView.addChildView(simulatorView);
+            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
             simulatorViewAdded = true;
         }
         applySimulatorBounds(simWidth);
@@ -132,7 +134,7 @@ export function createViewManager(ctx) {
     function hideSimulator() {
         if (simulatorView && simulatorViewAdded) {
             try {
-                ctx.mainWindow.contentView.removeChildView(simulatorView);
+                ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
             }
             catch (e) {
                 console.error('[workbench] hideSimulator error', e);
@@ -143,12 +145,20 @@ export function createViewManager(ctx) {
     async function showSettings() {
         if (!settingsView) {
             settingsView = new WebContentsView({
-                webPreferences: { nodeIntegration: true, contextIsolation: false },
+                webPreferences: {
+                    nodeIntegration: false,
+                    contextIsolation: true,
+                    sandbox: false,
+                    preload: mainPreloadPath,
+                },
             });
+            // Overlay loads mainPreloadPath, so the same navigation rules as the
+            // main window apply — see navigation-hardening.ts.
+            applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
             await settingsView.webContents.loadFile(path.join(ctx.rendererDir, 'entries/settings/index.html'));
         }
         if (!settingsViewAdded) {
-            ctx.mainWindow.contentView.addChildView(settingsView);
+            ctx.windows.mainWindow.contentView.addChildView(settingsView);
             settingsViewAdded = true;
         }
         applySettingsBounds();
@@ -156,7 +166,7 @@ export function createViewManager(ctx) {
     function hideSettings() {
         if (settingsView && settingsViewAdded) {
             try {
-                ctx.mainWindow.contentView.removeChildView(settingsView);
+                ctx.windows.mainWindow.contentView.removeChildView(settingsView);
             }
             catch { /* ignore */ }
             settingsViewAdded = false;
@@ -165,11 +175,18 @@ export function createViewManager(ctx) {
     function showPopover(data) {
         hidePopover();
         const popover = new WebContentsView({
-            webPreferences: { nodeIntegration: true, contextIsolation: false },
+            webPreferences: {
+                nodeIntegration: false,
+                contextIsolation: true,
+                sandbox: false,
+                preload: mainPreloadPath,
+            },
         });
+        // Popover overlay loads mainPreloadPath — same navigation rules apply.
+        applyNavigationHardening(popover.webContents, ctx.rendererDir);
         popoverView = popover;
         popover.setBackgroundColor('#00000000');
-        ctx.mainWindow.contentView.addChildView(popover);
+        ctx.windows.mainWindow.contentView.addChildView(popover);
         applyPopoverBounds();
         popover.webContents.once('did-finish-load', () => {
             ctx.notify.popoverInit(popover, data);
@@ -194,16 +211,6 @@ export function createViewManager(ctx) {
     function disposeAll() {
         detachSimulator();
     }
-    function logChildViews(_label) {
-        // Debug helper — intentionally a no-op in production. Kept on the
-        // ViewManager interface so call sites and tests stay stable.
-    }
-    function positionSimulator(simWidth) {
-        applySimulatorBounds(simWidth);
-    }
-    function positionSettings() {
-        applySettingsBounds();
-    }
     function resize(simWidth) {
         lastSimWidth = simWidth;
         if (simulatorViewAdded)
@@ -233,10 +240,13 @@ export function createViewManager(ctx) {
         hidePopover,
         repositionAll,
         disposeAll,
-        logChildViews,
-        positionSimulator,
-        positionSettings,
         getSimulatorWebContentsId: () => simulatorWebContentsId,
+        getSimulatorWebContents: () => {
+            if (simulatorWebContentsId == null)
+                return null;
+            const wc = webContents.fromId(simulatorWebContentsId);
+            return wc && !wc.isDestroyed() ? wc : null;
+        },
         getLastSimWidth: () => lastSimWidth,
         isSimulatorAdded: () => simulatorViewAdded,
         hasSimulatorView: () => simulatorView !== null,
@@ -247,6 +257,20 @@ export function createViewManager(ctx) {
                 return null;
             return settingsView.webContents;
         },
+        getSettingsWebContentsId: () => {
+            if (!settingsView)
+                return null;
+            if (settingsView.webContents.isDestroyed())
+                return null;
+            return settingsView.webContents.id;
+        },
+        getPopoverWebContentsId: () => {
+            if (!popoverView)
+                return null;
+            if (popoverView.webContents.isDestroyed())
+                return null;
+            return popoverView.webContents.id;
+        },
         resize,
         setVisible,
     };

package/dist/main/services/window-service.d.ts

@@ -0,0 +1,24 @@
+import type { BrowserWindow } from 'electron';
+/**
+ * Owns every top-level BrowserWindow the workbench is responsible for.
+ *
+ * This service is the single source of truth for the main and settings
+ * windows; callers reach them via `ctx.windows.mainWindow` /
+ * `ctx.windows.settingsWindow`.
+ */
+export interface WindowService {
+    /** The primary devtools window. Created during app bootstrap. */
+    readonly mainWindow: BrowserWindow;
+    /** Standalone workbench-settings BrowserWindow, or null when closed. */
+    readonly settingsWindow: BrowserWindow | null;
+    /** Update the tracked settings window (null when closed/destroyed). */
+    setSettingsWindow(win: BrowserWindow | null): void;
+    /** Close the settings window if it is open and clear the reference. */
+    closeSettingsWindow(): void;
+    /** True when `webContentsId` belongs to the (alive) main window renderer. */
+    isMainSender(webContentsId: number): boolean;
+    /** True when `webContentsId` belongs to the (alive) settings window renderer. */
+    isSettingsWindowSender(webContentsId: number): boolean;
+}
+export declare function createWindowService(mainWindow: BrowserWindow): WindowService;
+//# sourceMappingURL=window-service.d.ts.map

package/dist/main/services/window-service.js

@@ -0,0 +1,26 @@
+export function createWindowService(mainWindow) {
+    let settingsWin = null;
+    return {
+        get mainWindow() {
+            return mainWindow;
+        },
+        get settingsWindow() {
+            return settingsWin;
+        },
+        setSettingsWindow(win) {
+            settingsWin = win;
+        },
+        closeSettingsWindow() {
+            if (settingsWin && !settingsWin.isDestroyed())
+                settingsWin.close();
+            settingsWin = null;
+        },
+        isMainSender(id) {
+            return !mainWindow.isDestroyed() && mainWindow.webContents.id === id;
+        },
+        isSettingsWindowSender(id) {
+            return !!settingsWin && !settingsWin.isDestroyed() && settingsWin.webContents.id === id;
+        },
+    };
+}
+//# sourceMappingURL=window-service.js.map

package/dist/main/services/workbench-context.d.ts

@@ -1,20 +1,24 @@
 import type { BrowserWindow } from 'electron';
 import type { CompilationAdapter } from '../../shared/types.js';
+import { DisposableRegistry } from '../utils/disposable.js';
+import type { SenderPolicy } from '../utils/ipc-registry.js';
 import { type RendererNotifier } from './notifications/renderer-notifier.js';
 import { type ViewManager } from './views/view-manager.js';
+import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
+import { sanitizeTemplates } from './projects/templates.js';
+import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
  */
 export interface WorkbenchContext {
-    mainWindow: BrowserWindow;
     adapter: CompilationAdapter;
     /** Absolute path to the preload script loaded into the simulator webview */
     preloadPath: string;
     /** Absolute path to the renderer dist directory */
     rendererDir: string;
-    workbenchSettingsWindow: BrowserWindow | null;
     /** Built-in panel IDs to display (default: all) */
     panels: string[];
     /** Custom API namespace names (e.g. ['qd']) passed to the simulator */
@@ -37,10 +41,44 @@ export interface WorkbenchContext {
     };
     /** Unified lifecycle manager for all overlay WebContentsViews */
     views: ViewManager;
+    /** Owns BrowserWindow instances (main + settings) and their sender-id checks. */
+    windows: WindowService;
     /** Unified main → renderer event dispatcher */
     notify: RendererNotifier;
     /** Single source of truth for project + session + per-project settings */
     workspace: WorkspaceService;
+    /**
+     * Pluggable backend for the project list. Defaults to a LocalProjectsProvider
+     * that persists to `<userData>/dimina-projects.json`. Hosts can inject a
+     * custom implementation (e.g. read from a remote workspace).
+     */
+    projectsProvider: ProjectsProvider;
+    /**
+     * Merged template catalog used by the create-project flow. Combines the
+     * built-in templates with `WorkbenchAppConfig.projectTemplates` according
+     * to `WorkbenchAppConfig.builtinTemplates`. Keeps any `generate`
+     * functions intact — for IPC delivery, `sanitizeTemplates` is applied at
+     * the IPC boundary.
+     */
+    projectTemplates: ProjectTemplate[];
+    /**
+     * Optional host hook for the "新建项目" dialog. When present, the
+     * `projects:openCreateDialog` IPC returns whatever this hook resolves to;
+     * when absent, the IPC returns null and the renderer shows the built-in
+     * dialog.
+     */
+    customCreateProjectDialog?: (ctx: {
+        parentWindow: BrowserWindow;
+        templates: ProjectTemplate[];
+    }) => Promise<CustomCreateProjectDialogResult>;
+    /**
+     * Trust predicate consulted by `IpcRegistry` for every incoming IPC.
+     * Resolves the currently-trusted senders (main renderer + overlays)
+     * lazily so it stays correct as windows/views come and go.
+     */
+    senderPolicy: SenderPolicy;
+    /** Aggregates dispose handlers for every IPC handler, listener, watcher, and CDP session registered by the workbench. */
+    registry: DisposableRegistry;
 }
 export interface CreateContextOptions {
     mainWindow: BrowserWindow;
@@ -52,8 +90,17 @@ export interface CreateContextOptions {
     appName?: string;
     toolbarActions?: WorkbenchContext['toolbarActions'];
     brandingProvider?: WorkbenchContext['brandingProvider'];
+    /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
+    projectsProvider?: ProjectsProvider;
+    /** Templates injected by the host; same-id overrides a built-in. */
+    projectTemplates?: ProjectTemplate[];
+    /** Built-in template policy (default 'all'). */
+    builtinTemplates?: 'all' | 'none' | readonly string[];
+    /** Host-supplied "新建项目" dialog hook. */
+    customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
 }
 export declare function hasBuiltinPanel(ctx: Pick<WorkbenchContext, 'panels'>, panelId: string): boolean;
 export declare function getDefaultTab(ctx: Pick<WorkbenchContext, 'panels'>): string;
 export declare function createWorkbenchContext(opts: CreateContextOptions): WorkbenchContext;
+export { sanitizeTemplates };
 //# sourceMappingURL=workbench-context.d.ts.map

package/dist/main/services/workbench-context.js

@@ -1,7 +1,13 @@
+import { DisposableRegistry } from '../utils/disposable.js';
+import { createWorkbenchSenderPolicy } from '../utils/sender-policy.js';
 import { defaultAdapter } from './default-adapter.js';
 import { createRendererNotifier, } from './notifications/renderer-notifier.js';
 import { createViewManager } from './views/view-manager.js';
+import { createWindowService } from './window-service.js';
 import { createWorkspaceService, } from './workspace/workspace-service.js';
+import { createLocalProjectsProvider } from './projects/local-provider.js';
+import { resolveTemplates, sanitizeTemplates } from './projects/templates.js';
+import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
 export function hasBuiltinPanel(ctx, panelId) {
     return ctx.panels.includes(panelId);
 }
@@ -14,7 +20,6 @@ export function getDefaultTab(ctx) {
 }
 export function createWorkbenchContext(opts) {
     const ctx = {
-        mainWindow: opts.mainWindow,
         adapter: opts.adapter ?? defaultAdapter,
         preloadPath: opts.preloadPath,
         rendererDir: opts.rendererDir,
@@ -23,11 +28,19 @@ export function createWorkbenchContext(opts) {
         appName: opts.appName ?? 'Dimina DevTools',
         toolbarActions: opts.toolbarActions,
         brandingProvider: opts.brandingProvider,
-        workbenchSettingsWindow: null,
     };
+    ctx.registry = new DisposableRegistry();
+    ctx.windows = createWindowService(opts.mainWindow);
     ctx.views = createViewManager(ctx);
     ctx.notify = createRendererNotifier(ctx);
+    ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
+    ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
+    ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
     ctx.workspace = createWorkspaceService(ctx);
+    ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
     return ctx;
 }
+// Re-export at this stable module path so callers don't have to know about
+// the projects/ subtree layout.
+export { sanitizeTemplates };
 //# sourceMappingURL=workbench-context.js.map

package/dist/main/services/workspace/workspace-service.d.ts

@@ -25,10 +25,11 @@ export interface OpenProjectResult {
  * rather than touching the repository or adapter directly.
  */
 export interface WorkspaceService {
-    listProjects(): Project[];
-    addProject(dirPath: string): Project;
-    removeProject(dirPath: string): void;
-    validateProjectDir(dirPath: string): string | null;
+    listProjects(): Promise<Project[]>;
+    addProject(dirPath: string): Promise<Project>;
+    removeProject(dirPath: string): Promise<void>;
+    hasProject(dirPath: string): Promise<boolean>;
+    validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;
     closeProject(): Promise<void>;
     getSession(): {
@@ -38,9 +39,11 @@ export interface WorkspaceService {
     } | null;
     getProjectPath(): string;
     hasActiveSession(): boolean;
+    captureThumbnail(projectPath: string): Promise<string | null>;
+    getThumbnail(projectPath: string): Promise<string | null>;
     getProjectPages(projectPath: string): ProjectPages;
-    getCompileConfig(projectPath: string): CompileConfig;
-    saveCompileConfig(projectPath: string, config: CompileConfig): void;
+    getCompileConfig(projectPath: string): Promise<CompileConfig>;
+    saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
     getProjectSettings(projectPath: string): ProjectSettings;
     updateProjectSettings(projectPath: string, patch: Partial<ProjectSettings>): void;
 }

package/dist/main/services/workspace/workspace-service.js

@@ -1,11 +1,13 @@
 import * as repo from '../projects/project-repository.js';
+import { DEFAULT_COMPILE_CONFIG } from '../projects/types.js';
 import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
+import { loadWorkbenchSettings } from '../settings/index.js';
 /** Build a workspace service bound to the given workbench context. */
 export function createWorkspaceService(ctx) {
     let currentSession = null;
     let currentProjectPath = '';
-    function sendStatus(status, message) {
-        ctx.notify.projectStatus({ status, message });
+    function sendStatus(status, message, hotReload) {
+        ctx.notify.projectStatus(hotReload ? { status, message, hotReload: true } : { status, message });
     }
     function bestEffort(label, fn) {
         try {
@@ -36,11 +38,25 @@ export function createWorkspaceService(ctx) {
             setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined);
         }
     }
+    // Delegate to the host-injected (or default LocalProjectsProvider)
+    // ProjectsProvider on the context. When the host omits an optional method,
+    // we apply a safe documented default — never silently fall back to
+    // `repo.*`, because a remote provider's project paths are not on the local
+    // filesystem.
+    const provider = ctx.projectsProvider;
     return {
-        listProjects: () => repo.listProjects(),
-        addProject: (dirPath) => repo.addProject(dirPath),
-        removeProject: (dirPath) => repo.removeProject(dirPath),
-        validateProjectDir: (dirPath) => repo.validateProjectDir(dirPath),
+        listProjects: async () => provider.listProjects(),
+        addProject: async (dirPath) => provider.addProject(dirPath),
+        removeProject: async (dirPath) => {
+            await provider.removeProject(dirPath);
+        },
+        hasProject: async (dirPath) => {
+            const projects = await provider.listProjects();
+            return projects.some((p) => p.path === dirPath);
+        },
+        validateProjectDir: async (dirPath) => provider.validateProjectDir
+            ? provider.validateProjectDir(dirPath)
+            : null,
         async openProject(projectPath) {
             clearSimulatorServicewechatReferer();
             await disposeSession();
@@ -52,18 +68,22 @@ export function createWorkspaceService(ctx) {
             // `fetch(…).then(r=>r.text()).then(JSON.parse)` pipeline dies on the
             // dev server's HTML SPA fallback with
             // `SyntaxError: Unexpected token '<', "<!doctype "…`.
-            const dirError = repo.validateProjectDir(projectPath);
+            const dirError = provider.validateProjectDir
+                ? await provider.validateProjectDir(projectPath)
+                : null;
             if (dirError) {
                 sendStatus('error', dirError);
                 return { success: false, error: dirError };
             }
             sendStatus('compiling', '正在编译...');
+            const { compile } = loadWorkbenchSettings();
             let session;
             try {
                 session = await ctx.adapter.openProject({
                     projectPath,
                     sourcemap: true,
-                    onRebuild: () => sendStatus('ready', '编译完成，已热更新'),
+                    watch: compile.watch,
+                    onRebuild: () => sendStatus('ready', '编译完成，已热更新', true),
                     onBuildError: (err) => sendStatus('error', String(err)),
                 });
             }
@@ -74,7 +94,10 @@ export function createWorkspaceService(ctx) {
             }
             currentSession = session;
             currentProjectPath = projectPath;
-            bestEffort('updateLastOpened', () => repo.updateLastOpened(projectPath));
+            bestEffort('updateLastOpened', () => {
+                if (provider.updateLastOpened)
+                    provider.updateLastOpened(projectPath);
+            });
             bestEffort('sendStatus', () => sendStatus('ready', '编译完成'));
             bestEffort('applyReferer', () => applyRefererFromSession(session));
             return {
@@ -92,9 +115,46 @@ export function createWorkspaceService(ctx) {
         getSession: () => currentSession,
         getProjectPath: () => currentProjectPath,
         hasActiveSession: () => currentSession !== null,
+        async captureThumbnail(projectPath) {
+            const wc = ctx.views.getSimulatorWebContents();
+            if (!wc)
+                return null;
+            try {
+                const image = await wc.capturePage();
+                const dataUrl = `data:image/png;base64,${image.toPNG().toString('base64')}`;
+                if (provider.saveThumbnail) {
+                    await provider.saveThumbnail(projectPath, dataUrl);
+                }
+                // Always hand the renderer back the freshly-captured frame so the
+                // UI updates immediately even if the host's saveThumbnail is
+                // async or stores out-of-band.
+                return dataUrl;
+            }
+            catch {
+                return null;
+            }
+        },
+        async getThumbnail(projectPath) {
+            if (provider.getThumbnail) {
+                return (await provider.getThumbnail(projectPath)) ?? null;
+            }
+            return null;
+        },
+        // `getProjectPages` reads the project's own `app.json` from disk and is
+        // independent of the project registry — it stays on the repo helper.
         getProjectPages: (projectPath) => repo.getProjectPages(projectPath),
-        getCompileConfig: (projectPath) => repo.getCompileConfig(projectPath),
-        saveCompileConfig: (projectPath, config) => repo.saveCompileConfig(projectPath, config),
+        getCompileConfig: async (projectPath) => (provider.getCompileConfig
+            ? await provider.getCompileConfig(projectPath)
+            : DEFAULT_COMPILE_CONFIG),
+        saveCompileConfig: async (projectPath, config) => {
+            if (provider.saveCompileConfig) {
+                await provider.saveCompileConfig(projectPath, config);
+            }
+            // No persistence when the host opts out; the renderer's edits then
+            // do not survive a reload, matching the documented contract.
+        },
+        // Per-project settings (uploadWithSourceMap etc.) live in the project's
+        // own `project.config.json`, not the registry — keep direct repo calls.
         getProjectSettings: (projectPath) => repo.getProjectSettings(projectPath),
         updateProjectSettings: (projectPath, patch) => repo.updateProjectSettings(projectPath, patch),
     };

package/dist/main/simulator-apis.d.ts

@@ -0,0 +1,23 @@
+import { type SimulatorApiHandler } from './services/simulator/custom-apis.js';
+export type { SimulatorApiHandler } from './services/simulator/custom-apis.js';
+/**
+ * Register a handler for a simulator API callable from mini-program code.
+ *
+ * The handler runs in the Electron main process (Node.js context) and may
+ * use any main-process capability (filesystem, network, native deps). When
+ * the mini-program invokes `wx.<name>(params)` inside the simulator, the
+ * simulator forwards the call over IPC and resolves to the handler's return
+ * value. Errors thrown by the handler propagate back as a rejection.
+ *
+ * Re-registering the same name silently replaces the previous handler.
+ * The returned disposer removes only the registration it created — if the
+ * name was overwritten by a later `registerSimulatorApi`, calling the
+ * earlier disposer is a no-op.
+ *
+ * @example
+ *   registerSimulatorApi('myCompany.login', async ({ username }) => {
+ *     return await callInternalAuth(username)
+ *   })
+ */
+export declare function registerSimulatorApi(name: string, handler: SimulatorApiHandler): () => void;
+//# sourceMappingURL=simulator-apis.d.ts.map

package/dist/main/simulator-apis.js

@@ -0,0 +1,24 @@
+import { simulatorApiRegistry } from './services/simulator/custom-apis.js';
+/**
+ * Register a handler for a simulator API callable from mini-program code.
+ *
+ * The handler runs in the Electron main process (Node.js context) and may
+ * use any main-process capability (filesystem, network, native deps). When
+ * the mini-program invokes `wx.<name>(params)` inside the simulator, the
+ * simulator forwards the call over IPC and resolves to the handler's return
+ * value. Errors thrown by the handler propagate back as a rejection.
+ *
+ * Re-registering the same name silently replaces the previous handler.
+ * The returned disposer removes only the registration it created — if the
+ * name was overwritten by a later `registerSimulatorApi`, calling the
+ * earlier disposer is a no-op.
+ *
+ * @example
+ *   registerSimulatorApi('myCompany.login', async ({ username }) => {
+ *     return await callInternalAuth(username)
+ *   })
+ */
+export function registerSimulatorApi(name, handler) {
+    return simulatorApiRegistry.register(name, handler);
+}
+//# sourceMappingURL=simulator-apis.js.map

package/dist/main/utils/disposable.d.ts

@@ -0,0 +1,13 @@
+export interface Disposable {
+    dispose(): void | Promise<void>;
+}
+export type DisposeFn = () => void | Promise<void>;
+export declare function toDisposable(fn: DisposeFn): Disposable;
+export declare class DisposableRegistry implements Disposable {
+    private entries;
+    private _disposed;
+    add(d: Disposable | DisposeFn): Disposable;
+    disposeAll(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/main/utils/disposable.js

@@ -0,0 +1,60 @@
+export function toDisposable(fn) {
+    let done = false;
+    return {
+        dispose() {
+            if (done)
+                return;
+            done = true;
+            return fn();
+        },
+    };
+}
+export class DisposableRegistry {
+    entries = [];
+    _disposed = false;
+    add(d) {
+        if (this._disposed) {
+            throw new Error('cannot add to disposed registry');
+        }
+        const fn = typeof d === 'function' ? d : () => d.dispose();
+        const entry = { fn, released: false };
+        this.entries.push(entry);
+        return {
+            dispose: () => {
+                if (entry.released)
+                    return;
+                entry.released = true;
+                const i = this.entries.indexOf(entry);
+                if (i >= 0)
+                    this.entries.splice(i, 1);
+                return fn();
+            },
+        };
+    }
+    async disposeAll() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        const items = this.entries.slice().reverse();
+        this.entries = [];
+        const errors = [];
+        for (const entry of items) {
+            if (entry.released)
+                continue;
+            entry.released = true;
+            try {
+                await entry.fn();
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'DisposableRegistry encountered errors during disposeAll');
+        }
+    }
+    dispose() {
+        return this.disposeAll();
+    }
+}
+//# sourceMappingURL=disposable.js.map