@dimina-kit/devtools 0.4.0 → 0.5.0

package/dist/main/ipc/device-picker.d.ts

@@ -0,0 +1,16 @@
+import type { WorkbenchModule } from '../services/module.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
+/** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
+ * (the gate in eslint.config.* is shrink-only; see its message). */
+export interface DevicePickerIpcDeps {
+    views: Pick<ViewManager, 'showDevicePicker' | 'hideDevicePicker'>;
+    notify: Pick<RendererNotifier, 'devicePickerSelected'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerDevicePickerIpc(input: IpcInput<DevicePickerIpcDeps>): Disposable;
+export declare const devicePickerModule: WorkbenchModule;
+//# sourceMappingURL=device-picker.d.ts.map

package/dist/main/ipc/device-picker.js

@@ -0,0 +1,27 @@
+import { DevicePickerChannel } from '../../shared/ipc-channels-overlays.js';
+import { DevicePickerDeviceSchema } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerDevicePickerIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .onRouted(DevicePickerChannel.Show, (ctx, _event, ...args) => {
+        const [data] = validate(DevicePickerChannel.Show, DevicePickerDeviceSchema, args);
+        ctx.views.showDevicePicker(data);
+    })
+        .onRouted(DevicePickerChannel.Cancel, (ctx) => {
+        ctx.views.hideDevicePicker();
+    })
+        .onRouted(DevicePickerChannel.Select, (ctx, _event, ...args) => {
+        const [data] = validate(DevicePickerChannel.Select, DevicePickerDeviceSchema, args);
+        ctx.views.hideDevicePicker();
+        ctx.notify.devicePickerSelected(data);
+    });
+    // OverlayChannel.Ready is registered once, in tooltip.ts — every overlay
+    // renderer (this one included) funnels readiness through that single
+    // listener, so a second registration here would double-fire markOverlayReady.
+}
+export const devicePickerModule = {
+    setup: (ctx) => registerDevicePickerIpc(ctx),
+};
+//# sourceMappingURL=device-picker.js.map

package/dist/main/ipc/index.d.ts

@@ -1,8 +1,13 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerTooltipIpc, tooltipModule } from './tooltip.js';
+export { registerProjectCreateIpc, projectCreateModule } from './project-create.js';
+export { registerDevicePickerIpc, devicePickerModule } from './device-picker.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
+export { registerInternalDevtoolsIpc } from './internal-devtools.js';
+export { registerViewsIpc } from './views.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -1,8 +1,13 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerTooltipIpc, tooltipModule } from './tooltip.js';
+export { registerProjectCreateIpc, projectCreateModule } from './project-create.js';
+export { registerDevicePickerIpc, devicePickerModule } from './device-picker.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
+export { registerInternalDevtoolsIpc } from './internal-devtools.js';
+export { registerViewsIpc } from './views.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/internal-devtools.d.ts

@@ -0,0 +1,16 @@
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
+import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+/**
+ * Standalone internal (app-wide) DevTools debug window. The simulator
+ * toolbar's "debug" button opens (or focuses) it via the window controller —
+ * a module-local narrow deps interface, not `WorkbenchContext`, per the
+ * shrink-only WorkbenchContext-import gate (see eslint.config.js).
+ */
+export interface InternalDevtoolsIpcDeps {
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
+    senderPolicy: SenderPolicy;
+}
+export declare function registerInternalDevtoolsIpc(input: IpcInput<InternalDevtoolsIpcDeps>): Disposable;
+//# sourceMappingURL=internal-devtools.d.ts.map

package/dist/main/ipc/internal-devtools.js

@@ -0,0 +1,10 @@
+import { InternalDevtoolsChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerInternalDevtoolsIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(InternalDevtoolsChannel.Open, (ctx) => {
+        ctx.internalDevtoolsWindow?.open();
+    });
+}
+//# sourceMappingURL=internal-devtools.js.map

package/dist/main/ipc/page-scroll.d.ts

@@ -1,14 +1,2 @@
-/**
- * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
- *
- * The mini-program page scrolls the whole render document (the native iOS impl
- * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
- * simulator scrolls `window`. `duration` is best-effort: a positive duration
- * maps to smooth scrolling (the browser owns the easing — the exact ms is not
- * controllable), and `0` jumps instantly.
- */
-export declare function buildPageScrollScript(params: {
-    scrollTop?: unknown;
-    duration?: unknown;
-}): string;
+export * from '@dimina-kit/electron-runtime/main/page-scroll';
 //# sourceMappingURL=page-scroll.d.ts.map

package/dist/main/ipc/page-scroll.js

@@ -1,17 +1,2 @@
-/**
- * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
- *
- * The mini-program page scrolls the whole render document (the native iOS impl
- * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
- * simulator scrolls `window`. `duration` is best-effort: a positive duration
- * maps to smooth scrolling (the browser owns the easing — the exact ms is not
- * controllable), and `0` jumps instantly.
- */
-export function buildPageScrollScript(params) {
-    const rawTop = Number(params.scrollTop);
-    const top = Number.isFinite(rawTop) ? rawTop : 0;
-    const duration = params.duration === undefined ? 300 : Number(params.duration);
-    const behavior = Number.isFinite(duration) && duration > 0 ? 'smooth' : 'auto';
-    return `window.scrollTo({ top: ${top}, left: 0, behavior: ${JSON.stringify(behavior)} })`;
-}
+export * from '@dimina-kit/electron-runtime/main/page-scroll';
 //# sourceMappingURL=page-scroll.js.map

package/dist/main/ipc/popover.d.ts

@@ -1,6 +1,9 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type PopoverIpcCtx = Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy' | 'workspace'>;
+export declare function registerPopoverIpc(input: IpcInput<PopoverIpcCtx>): Disposable;
 export declare const popoverModule: WorkbenchModule;
+export {};
 //# sourceMappingURL=popover.d.ts.map

package/dist/main/ipc/popover.js

@@ -1,29 +1,36 @@
-import { PopoverChannel } from '../../shared/ipc-channels.js';
-import { PopoverShowSchema, PopoverRelaunchSchema, PopoverSwitchLaunchConfigSchema, PopoverUpdateLaunchConfigsSchema, } from '../../shared/ipc-schemas.js';
+import { PopoverChannel } from '../../shared/ipc-channels-overlays.js';
+import { PopoverShowSchema, PopoverApplySchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerPopoverIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(PopoverChannel.Show, (_event, ...args) => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerPopoverIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(PopoverChannel.Show, (ctx, _event, ...args) => {
         const [data] = validate(PopoverChannel.Show, PopoverShowSchema, args);
-        ctx.views.showPopover(data);
+        // A stale/misbehaving renderer may still send the old `modes` field —
+        // never trust it. The live state always comes from the currently open
+        // project's store, injected here.
+        const { modes: _modes, ...rest } = data;
+        const { state } = ctx.workspace.getCompileModeState();
+        ctx.views.showPopover({ ...rest, state });
     })
-        .handle(PopoverChannel.Hide, () => {
+        .handleRouted(PopoverChannel.Hide, (ctx) => {
         ctx.views.hidePopover();
     })
-        .on(PopoverChannel.Relaunch, (_event, ...args) => {
-        const [newConfig] = validate(PopoverChannel.Relaunch, PopoverRelaunchSchema, args);
+        .handleRouted(PopoverChannel.Apply, async (ctx, _event, ...args) => {
+        const [payload] = validate(PopoverChannel.Apply, PopoverApplySchema, args);
+        // Hide BEFORE touching the store: a slow or failing apply must never
+        // leave a stale popover window on screen.
         ctx.views.hidePopover();
-        ctx.notify.popoverRelaunch(newConfig);
-    })
-        .on(PopoverChannel.SwitchLaunchConfig, (_event, ...args) => {
-        const [id] = validate(PopoverChannel.SwitchLaunchConfig, PopoverSwitchLaunchConfigSchema, args);
-        ctx.views.hidePopover();
-        ctx.notify.popoverSwitchLaunchConfig(id);
-    })
-        .on(PopoverChannel.UpdateLaunchConfigs, (_event, ...args) => {
-        const [configs] = validate(PopoverChannel.UpdateLaunchConfigs, PopoverUpdateLaunchConfigsSchema, args);
-        ctx.notify.popoverUpdateLaunchConfigs(configs);
+        try {
+            return await ctx.workspace.applyCompileModeCommand(payload.command);
+        }
+        catch (err) {
+            ctx.notify.compileModesApplyFailed({
+                message: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     });
 }
 export const popoverModule = {

package/dist/main/ipc/project-create.d.ts

@@ -0,0 +1,16 @@
+import type { WorkbenchModule } from '../services/module.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
+/** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
+ * (the gate in eslint.config.* is shrink-only; see its message). */
+export interface ProjectCreateIpcDeps {
+    views: Pick<ViewManager, 'showProjectCreateDialog' | 'hideProjectCreateDialog'>;
+    notify: Pick<RendererNotifier, 'projectCreateSubmitted'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerProjectCreateIpc(input: IpcInput<ProjectCreateIpcDeps>): Disposable;
+export declare const projectCreateModule: WorkbenchModule;
+//# sourceMappingURL=project-create.d.ts.map

package/dist/main/ipc/project-create.js

@@ -0,0 +1,27 @@
+import { ProjectCreateChannel } from '../../shared/ipc-channels-overlays.js';
+import { ProjectCreateShowSchema, ProjectCreateSubmitSchema } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerProjectCreateIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .onRouted(ProjectCreateChannel.Show, (ctx, _event, ...args) => {
+        const [data] = validate(ProjectCreateChannel.Show, ProjectCreateShowSchema, args);
+        ctx.views.showProjectCreateDialog(data);
+    })
+        .onRouted(ProjectCreateChannel.Cancel, (ctx) => {
+        ctx.views.hideProjectCreateDialog();
+    })
+        .onRouted(ProjectCreateChannel.Submit, (ctx, _event, ...args) => {
+        const [input] = validate(ProjectCreateChannel.Submit, ProjectCreateSubmitSchema, args);
+        ctx.views.hideProjectCreateDialog();
+        ctx.notify.projectCreateSubmitted(input);
+    });
+    // OverlayChannel.Ready is registered once, in tooltip.ts — every overlay
+    // renderer (this one included) funnels readiness through that single
+    // listener, so a second registration here would double-fire markOverlayReady.
+}
+export const projectCreateModule = {
+    setup: (ctx) => registerProjectCreateIpc(ctx),
+};
+//# sourceMappingURL=project-create.js.map

package/dist/main/ipc/project-fs.d.ts

@@ -1,5 +1,16 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type IpcInput } from '../utils/ipc-context-source.js';
+/** Dependency/VCS/build directories invisible to every project-tree consumer:
+ * IPC `listFiles`, the `/__fs/readdir` bridge (so the workbench mirror and the
+ * WAL ledger seed never walk into them), and the `/__fs/watch` change stream.
+ * Derived from devkit's `WATCH_IGNORE_DIRS` (the shared never-source core:
+ * node_modules + VCS) so the `node_modules` omission that once wedged
+ * `watcher.close()` can never drift back on this side, PLUS the editor mirror's
+ * own build-output names (`dist`/`build`/tool caches) — which the devkit
+ * recompile watcher deliberately does NOT ignore, since app.json may declare
+ * pages under such paths. */
+export declare const SKIP_DIRS: ReadonlySet<string>;
 /**
  * Synchronous, string-level guard: reject empty root (ENOACTIVE), NUL bytes
  * and empty paths (EINVAL), and lexical `..` escapes (EACCES) by resolving
@@ -75,8 +86,31 @@ export declare function writeFile(root: string, p: string, content: string | Buf
  * out-of-sandbox metadata. `rel` is a project-root-relative bridge path.
  */
 export declare function statWithin(root: string, rel: string): Promise<import('node:fs').Stats>;
-/** Realpath-contained `fs.readdir` twin (see {@link statWithin}). */
-export declare function readdirWithin(root: string, rel: string): Promise<import('node:fs').Dirent[]>;
+/**
+ * One `readdirWithin` result entry. Directories carry no stat (the caller —
+ * the `/__fs/readdir` bridge handler — never needs it: a directory recurses
+ * instead of being compared). `size`/`mtimeMs` are omitted (not `null`) when
+ * the entry raced a concurrent delete between `readdir` and `stat` — the
+ * bridge wire format then drops them too, which the sync engine's watch
+ * expansion (@dimina-kit/fs-core/sync/watch-expander) treats as
+ * "always changed" rather than risking a false stat match.
+ */
+export interface ReaddirStatEntry {
+    name: string;
+    isDirectory: boolean;
+    size?: number;
+    mtimeMs?: number;
+}
+/**
+ * Realpath-contained `fs.readdir` twin (see {@link statWithin}) that also
+ * `fs.stat`s every FILE entry (size + mtimeMs) — the disk-side half of the
+ * sync engine's stat-diffing (see @dimina-kit/fs-core/sync/watch-expander's module doc):
+ * a watch-reported directory is only worth a full content re-read when a
+ * file's stat inside it actually moved, and the `/__fs/readdir` bridge is
+ * the one HTTP round trip cheap enough to do that check on every watch
+ * event without itself re-reading file bytes.
+ */
+export declare function readdirWithin(root: string, rel: string): Promise<ReaddirStatEntry[]>;
 /**
  * Raw-byte read twin of {@link readFileBuffer} taking a project-root-relative
  * bridge path (the COI `/__fs/read` bridge), with the same realpath +
@@ -115,7 +149,8 @@ declare function listFiles(root: string, rootArg: string): Promise<string[]>;
  * Register the project-fs IPC channels. Call once during workbench setup;
  * the returned Disposable removes every channel (park on `ctx.registry`).
  */
-export declare function registerProjectFsIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>): Disposable;
+type ProjectFsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>;
+export declare function registerProjectFsIpc(input: IpcInput<ProjectFsIpcCtx>): Disposable;
 /** Test seams — pure handlers, no Electron needed. */
 export declare const __testing: {
     readFile: typeof readFile;

package/dist/main/ipc/project-fs.js

@@ -45,13 +45,24 @@ import nodeFs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
 import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
 import { validate } from '../utils/ipc-schema.js';
 import { ProjectFsChannel } from '../../shared/ipc-channels.js';
+import { WATCH_IGNORE_DIRS } from '@dimina-kit/devkit/watch-ignore';
 /** Cap for `listFiles` — huge monorepos would otherwise stall the renderer. */
 const LIST_FILE_LIMIT = 5000;
-const SKIP_DIRS = new Set([
-    'node_modules', '.git', '.svn', '.hg', 'dist', 'build',
-    '.next', '.cache', '.turbo', '.parcel-cache', '.nuxt', '.output', '.vite',
+/** Dependency/VCS/build directories invisible to every project-tree consumer:
+ * IPC `listFiles`, the `/__fs/readdir` bridge (so the workbench mirror and the
+ * WAL ledger seed never walk into them), and the `/__fs/watch` change stream.
+ * Derived from devkit's `WATCH_IGNORE_DIRS` (the shared never-source core:
+ * node_modules + VCS) so the `node_modules` omission that once wedged
+ * `watcher.close()` can never drift back on this side, PLUS the editor mirror's
+ * own build-output names (`dist`/`build`/tool caches) — which the devkit
+ * recompile watcher deliberately does NOT ignore, since app.json may declare
+ * pages under such paths. */
+export const SKIP_DIRS = new Set([
+    ...WATCH_IGNORE_DIRS,
+    'dist', 'build', '.next', '.cache', '.turbo', '.parcel-cache', '.nuxt', '.output', '.vite',
 ]);
 const PathArg = z.string().min(1);
 const ReadFileSchema = z.tuple([PathArg]);
@@ -316,10 +327,31 @@ export async function statWithin(root, rel) {
     const safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
     return fs.stat(safe);
 }
-/** Realpath-contained `fs.readdir` twin (see {@link statWithin}). */
+/**
+ * Realpath-contained `fs.readdir` twin (see {@link statWithin}) that also
+ * `fs.stat`s every FILE entry (size + mtimeMs) — the disk-side half of the
+ * sync engine's stat-diffing (see @dimina-kit/fs-core/sync/watch-expander's module doc):
+ * a watch-reported directory is only worth a full content re-read when a
+ * file's stat inside it actually moved, and the `/__fs/readdir` bridge is
+ * the one HTTP round trip cheap enough to do that check on every watch
+ * event without itself re-reading file bytes.
+ */
 export async function readdirWithin(root, rel) {
     const safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
-    return fs.readdir(safe, { withFileTypes: true });
+    const dirents = await fs.readdir(safe, { withFileTypes: true });
+    return Promise.all(dirents.map(async (d) => {
+        if (d.isDirectory())
+            return { name: d.name, isDirectory: true };
+        try {
+            const st = await fs.stat(path.join(safe, d.name));
+            return { name: d.name, isDirectory: false, size: st.size, mtimeMs: st.mtimeMs };
+        }
+        catch {
+            // Entry vanished (or became unreadable) between readdir and stat —
+            // report it stat-less; see this function's doc for why that is safe.
+            return { name: d.name, isDirectory: false };
+        }
+    }));
 }
 /**
  * Raw-byte read twin of {@link readFileBuffer} taking a project-root-relative
@@ -521,44 +553,43 @@ async function listFiles(root, rootArg) {
     }
     return out;
 }
-/**
- * Register the project-fs IPC channels. Call once during workbench setup;
- * the returned Disposable removes every channel (park on `ctx.registry`).
- */
-export function registerProjectFsIpc(ctx) {
-    const getRoot = () => ctx.workspace.getProjectPath();
-    const getLastClosedRoot = () => ctx.workspace.getLastClosedProjectPath();
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(ProjectFsChannel.GetRoot, () => getRoot())
-        .handle(ProjectFsChannel.ReadFile, (_event, ...args) => {
+export function registerProjectFsIpc(input) {
+    // Roots are read per call from the CALLING window's workspace: each window
+    // has its own open project, so a captured root would sandbox one window's
+    // file access against another's project.
+    const getRoot = (ctx) => ctx.workspace.getProjectPath();
+    const getLastClosedRoot = (ctx) => ctx.workspace.getLastClosedProjectPath();
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(ProjectFsChannel.GetRoot, (ctx) => getRoot(ctx))
+        .handleRouted(ProjectFsChannel.ReadFile, (ctx, _event, ...args) => {
         const [p] = validate(ProjectFsChannel.ReadFile, ReadFileSchema, args);
         // Reads stay scoped to the CURRENT root only — never widen the read
         // surface to the last-closed project.
-        return readFile(getRoot(), p);
+        return readFile(getRoot(ctx), p);
     })
-        .handle(ProjectFsChannel.WriteFile, (_event, ...args) => {
+        .handleRouted(ProjectFsChannel.WriteFile, (ctx, _event, ...args) => {
         const [p, content] = validate(ProjectFsChannel.WriteFile, WriteFileSchema, args);
         // Accept a write under the current OR the just-closed project root (the
         // latter rescues an in-flight teardown flush after `closeProject`). The
         // selected root then runs the FULL sandbox (realpath containment +
         // ancestor guard + O_NOFOLLOW) inside `writeFile`, so the boundary is
         // never relaxed — only WHICH root is considered.
-        const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+        const root = pickWriteRoot(p, { current: getRoot(ctx), lastClosed: getLastClosedRoot(ctx) });
         return writeFile(root, p, content);
     })
-        .handleSync(ProjectFsChannel.WriteFileSync, (_event, ...args) => {
+        .handleSyncRouted(ProjectFsChannel.WriteFileSync, (ctx, _event, ...args) => {
         // Synchronous twin of WriteFile for the editor's beforeunload flush. Same
         // root selection + same sandbox (`writeFileSync` mirrors `writeFile`); the
         // only difference is the blocking transport. Returns `{ ok: true }`; any
         // throw is converted to `{ ok: false, code, message }` by `handleSync`.
         const [p, content] = validate(ProjectFsChannel.WriteFileSync, WriteFileSchema, args);
-        const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+        const root = pickWriteRoot(p, { current: getRoot(ctx), lastClosed: getLastClosedRoot(ctx) });
         writeFileSync(root, p, content);
         return { ok: true };
     })
-        .handle(ProjectFsChannel.ListFiles, (_event, ...args) => {
+        .handleRouted(ProjectFsChannel.ListFiles, (ctx, _event, ...args) => {
         const [p] = validate(ProjectFsChannel.ListFiles, ListFilesSchema, args);
-        return listFiles(getRoot(), p);
+        return listFiles(getRoot(ctx), p);
     });
 }
 /** Test seams — pure handlers, no Electron needed. */

package/dist/main/ipc/projects.d.ts

@@ -1,8 +1,8 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog'>;
-export declare function registerProjectsIpc(ctx: ProjectsIpcCtx): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+export type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'customEditProjectDialog' | 'notify' | 'views'>;
+export declare function registerProjectsIpc(input: IpcInput<ProjectsIpcCtx>): Disposable;
 export declare const projectsModule: WorkbenchModule;
-export {};
 //# sourceMappingURL=projects.d.ts.map

package/dist/main/ipc/projects.js

@@ -1,25 +1,26 @@
 import { app, dialog } from 'electron';
 import path from 'path';
 import { ProjectsChannel, DialogChannel } from '../../shared/ipc-channels.js';
-import { ProjectsAddSchema, ProjectsRemoveSchema, } from '../../shared/ipc-schemas.js';
+import { ProjectsAddSchema, ProjectsOpenEditDialogSchema, ProjectsRemoveSchema, ProjectsUpdateSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
 import { sanitizeTemplates } from '../services/projects/templates.js';
 import { createProject } from '../services/projects/create-project-service.js';
 import { loadWorkbenchSettings, saveWorkbenchSettings, } from '../services/settings/index.js';
-export function registerProjectsIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(ProjectsChannel.List, () => {
+export function registerProjectsIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(ProjectsChannel.List, (ctx) => {
         return ctx.workspace.listProjects();
     })
-        .handle(DialogChannel.OpenDirectory, async () => {
+        .handleRouted(DialogChannel.OpenDirectory, async (ctx) => {
         const result = await dialog.showOpenDialog(ctx.windows.mainWindow, {
             properties: ['openDirectory'],
             title: '选择小程序项目目录',
         });
         return result.canceled ? null : result.filePaths[0];
     })
-        .handle(ProjectsChannel.Add, async (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Add, async (ctx, _event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
         const dirError = await ctx.workspace.validateProjectDir(dirPath);
         if (dirError) {
@@ -43,20 +44,35 @@ export function registerProjectsIpc(ctx) {
                 buttons: ['确定'],
             });
         }
+        // Imported project's own detected type wins over whatever category the
+        // sidebar happened to be showing — the list would otherwise stay on
+        // the old category and hide the project that was just added. Drives
+        // both halves: the main-window list filter (existing notify channel,
+        // same one the sidebar's own click uses) and the sidebar rail's own
+        // highlight (a push down through its narrow bridge — the rail has no
+        // other way to learn about a selection that didn't originate from its
+        // own click).
+        const importedCategory = project.type ?? 'miniprogram';
+        ctx.notify.hostSidebarCategorySelected(importedCategory);
+        ctx.views.hostSidebar.send('project-category-forced', { category: importedCategory });
         return project;
     })
-        .handle(ProjectsChannel.Remove, (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Remove, (ctx, _event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
+    })
+        .handleRouted(ProjectsChannel.Update, (ctx, _event, ...args) => {
+        const [dirPath, patch] = validate(ProjectsChannel.Update, ProjectsUpdateSchema, args);
+        return ctx.workspace.updateProject(dirPath, patch);
     })
         // ── template catalog + create flow ──
-        .handle(ProjectsChannel.ListTemplates, () => {
+        .handleRouted(ProjectsChannel.ListTemplates, (ctx) => {
         // Sanitize at the IPC boundary: `generate` is a function and the
         // structured-clone algorithm Electron uses for invoke would otherwise
         // throw "could not be cloned" before the renderer ever sees it.
         return sanitizeTemplates(ctx.projectTemplates ?? []);
     })
-        .handle(ProjectsChannel.OpenCreateDialog, async () => {
+        .handleRouted(ProjectsChannel.OpenCreateDialog, async (ctx) => {
         if (!ctx.customCreateProjectDialog)
             return null;
         const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
@@ -65,7 +81,27 @@ export function registerProjectsIpc(ctx) {
             templates: sanitized,
         });
     })
-        .handle(ProjectsChannel.Create, async (_event, ...args) => {
+        .handleRouted(ProjectsChannel.OpenEditDialog, async (ctx, _event, ...args) => {
+        if (!ctx.customEditProjectDialog)
+            return null;
+        const [dirPath] = validate(ProjectsChannel.OpenEditDialog, ProjectsOpenEditDialogSchema, args);
+        // Read from the workspace, not the renderer's args — the host sees
+        // devtools' own authoritative record, never a client-supplied one.
+        const project = (await ctx.workspace.listProjects()).find((p) => p.path === dirPath);
+        if (!project)
+            throw new Error(`No such project: ${dirPath}`);
+        const result = await ctx.customEditProjectDialog({
+            parentWindow: ctx.windows.mainWindow,
+            project,
+        });
+        // Wrapped in `{ result }` so `null` on the wire means ONLY "no hook
+        // configured" (renderer falls back to the built-in dialog). A hook that
+        // ran and was cancelled resolves `result: null`, which the renderer
+        // must treat as "do nothing" — otherwise a cancelled host dialog would
+        // fall through into the built-in one right behind it.
+        return { result };
+    })
+        .handleRouted(ProjectsChannel.Create, async (ctx, _event, ...args) => {
         // We deliberately don't run this through zod yet — the input shape is
         // wide (any template can stash arbitrary `extra` fields) and the
         // service does its own per-field validation. Bound size to keep this
@@ -110,7 +146,7 @@ export function registerProjectsIpc(ctx) {
         }
         return project;
     })
-        .handle(ProjectsChannel.GetCreateDefaults, () => {
+        .handleRouted(ProjectsChannel.GetCreateDefaults, () => {
         // Fallback chain: persisted last parent → user's Documents → home.
         // Documents covers the common "我把项目都放在 Documents/ 下" case for
         // first-time users on macOS; home is just a safe final fallback.

package/dist/main/ipc/session-listener-bag.d.ts

@@ -1,41 +1,2 @@
-/**
- * Session-scoped listener bookkeeping. An app session hangs lifecycle hooks on
- * emitters it does NOT own — the shared simulator WebContentsView, a pooled
- * service-host window — and those emitters outlive the session (one simulator
- * wc soft-reloads through many sessions). Every such hook is registered
- * through this bag so the session's single teardown chokepoint can detach them
- * all with one `dispose()`; a hook left behind survives as a dead listener on
- * the shared emitter, growing by one per soft reload until Node's MaxListeners
- * warning fires.
- */
-type Listener = (...args: unknown[]) => void;
-/**
- * Structural surface of the Node/Electron emitters the bag manages.
- * `removeListener(event, fn)` also detaches a `once(event, fn)` registration:
- * Node's once wrapper keeps a `.listener` back-reference to `fn` and
- * removeListener matches through it. `isDestroyed` covers Electron objects
- * (WebContents / BrowserWindow) whose methods throw once destroyed.
- */
-export interface BagEmitter {
-    on(event: string, listener: Listener): unknown;
-    once(event: string, listener: Listener): unknown;
-    removeListener(event: string, listener: Listener): unknown;
-    isDestroyed?(): boolean;
-}
-export interface SessionListenerBag {
-    /** Attach `fn` via `emitter.on` and track it for dispose. No-op after dispose. */
-    on(emitter: BagEmitter, event: string, fn: Listener): void;
-    /** Attach `fn` via `emitter.once` and track it for dispose. No-op after dispose. */
-    once(emitter: BagEmitter, event: string, fn: Listener): void;
-    /**
-     * Detach every tracked listener that may still be attached. Emitters that
-     * report `isDestroyed()` are skipped — their listeners died with them, and
-     * touching a destroyed Electron object throws. Removing a `once` that
-     * already fired is a no-op, so dispose is safe to call FROM one of the
-     * bag's own hooks (teardown triggered by the hook itself). Idempotent.
-     */
-    dispose(): void;
-}
-export declare function createSessionListenerBag(): SessionListenerBag;
-export {};
+export * from '@dimina-kit/electron-runtime/main/session-listener-bag';
 //# sourceMappingURL=session-listener-bag.d.ts.map