@dimina-kit/devtools 0.4.0-dev.20260612025610 → 0.4.0-dev.20260615070430

package/dist/main/ipc/bridge-router.js

@@ -58,17 +58,26 @@ const API_CALL_TIMEOUT_MS = 5_000;
  * rather than assuming a single session.
  */
 function resolveCurrentApp(state, ctx, appId) {
+    // Same-appId matches prefer the MOST RECENT spawn (Maps preserve insertion
+    // order): after a respawn/reopen the newest session is the live one — the
+    // first match could be a just-superseded session mid-teardown.
     if (appId) {
+        let match;
         for (const ap of state.appSessions.values())
             if (ap.appId === appId)
-                return ap;
+                match = ap;
+        if (match)
+            return match;
     }
     const appInfo = ctx.workspace?.getSession?.()?.appInfo;
     const activeAppId = appInfo?.appId;
     if (activeAppId) {
+        let match;
         for (const ap of state.appSessions.values())
             if (ap.appId === activeAppId)
-                return ap;
+                match = ap;
+        if (match)
+            return match;
     }
     // Maps preserve insertion order; the last entry is the most recent spawn.
     let last;
@@ -87,6 +96,12 @@ export function installBridgeRouter(ctx) {
         emitRenderEvent: () => { },
         connections: ctx.connections,
         debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
+        evictAppDataBridges: (ap) => {
+            if (!ctx.appData)
+                return;
+            for (const page of ap.pages.values())
+                ctx.appData.evictBridge(ap.appId, page.bridgeId);
+        },
     };
     // Opt-in (default OFF) pre-warm pool for service-host windows. When enabled,
     // handleSpawn acquires a warm window instead of constructing one per spawn.
@@ -298,12 +313,8 @@ export function installBridgeRouter(ctx) {
             console.warn(`[bridge-router] DISPOSE rejected: sender belongs to ${senderApp.appSessionId}, target ${target.appSessionId}`);
             return;
         }
-        // Native-host AppData: clear the app's accumulated bridges so a re-opened
-        // project doesn't show ghost tabs from the prior session.
-        if (ctx.appData) {
-            for (const page of target.pages.values())
-                ctx.appData.evictBridge(target.appId, page.bridgeId);
-        }
+        // AppData bridge eviction happens inside disposeAppSession (single
+        // chokepoint shared with the simulator-WCV 'destroyed' path).
         void disposeAppSession(state, target.appSessionId);
     };
     ipcMain.on(C.DISPOSE, onDispose);
@@ -517,6 +528,19 @@ async function handleSpawn(state, ctx, event, opts) {
     };
     appSession.onServiceClosed = onServiceClosed;
     serviceWindow.once('closed', onServiceClosed);
+    // The simulator WCV owns the app's UI lifetime. When it is destroyed —
+    // project close (`views.disposeAll`/detach) or a DeviceShell respawn
+    // (`attachNativeSimulator`, e.g. watcher hot reload) — the guest never gets
+    // to send its graceful `C.DISPOSE`, so without this hook the app session and
+    // its hidden service-host window leak, and `resolveCurrentApp` keeps
+    // resolving the STALE session for the same appId: `getActiveRenderWc` then
+    // dereferences dead pages and every panel pull (WXML/elements) returns null
+    // for the whole next session. Disposing here is idempotent with the graceful
+    // path (`disposeAppSession` early-returns once the session is gone).
+    const onSimulatorDestroyed = () => {
+        void disposeAppSession(state, appSessionId);
+    };
+    simulatorWc.once('destroyed', onSimulatorDestroyed);
     if (usedPool) {
         // A pooled/fallback window passes through about:blank (warm load or the
         // fallback's initial load). Boot only once the REAL service.html navigation
@@ -1144,6 +1168,9 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     if (!ap)
         return;
     state.appSessions.delete(appSessionId);
+    // Evict AppData bridges FIRST — eviction enumerates `ap.pages`, which the
+    // page teardown below progressively empties (and finally clears).
+    state.evictAppDataBridges(ap);
     // Drain any pending API calls owned by this app session. One-shot calls
     // normally self-clean on response/timeout, but persistent (`keep: true`)
     // subscriptions (e.g. audioListen) live with their timer cleared until

package/dist/main/ipc/views.js

@@ -30,7 +30,16 @@ export function registerViewsIpc(ctx) {
         .handle(ViewChannel.HostToolbarBounds, (_event, ...args) => {
         const [bounds] = validate(ViewChannel.HostToolbarBounds, ViewBoundsSchema, args);
         ctx.views.setHostToolbarBounds(bounds);
-    });
+    })
+        // Height replay pull: a freshly-mounted main-renderer placeholder asks for
+        // the last NOTIFIED toolbar height (main retains it — the toolbar's
+        // size-advertiser deduplicates and never re-pushes, so a push that fired
+        // while no project view was mounted is otherwise lost: cold start races
+        // it, close-project → reopen hits it always). Rides the SAME
+        // senderPolicy-gated registry as HostToolbarBounds: the toolbar WCV's
+        // arbitrary host content must not reach this — only the trusted main
+        // renderer pulls. Live delegation, not a registration-time snapshot.
+        .handle(ViewChannel.HostToolbarGetHeight, () => ctx.views.getHostToolbarHeight());
     // Reverse size-advertiser: the toolbar WCV's OWN renderer sends this, and the
     // host loads ARBITRARY content into that WCV. We DELIBERATELY do NOT add the
     // toolbar wc to the global sender policy — that would trust it for ALL ~72

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

@@ -12,6 +12,15 @@ export interface ProjectStatusPayload {
     /** True when the status update is emitted by the file-watcher rebuild loop. */
     hotReload?: boolean;
 }
+/**
+ * Payload for the `project:compileLog` push — one filtered dmcc log line.
+ * `at` is stamped in the main process when the line is captured.
+ */
+export interface CompileLogPayload {
+    at: number;
+    stream: 'stdout' | 'stderr';
+    text: string;
+}
 /**
  * Payload for the `settings:init` event sent into the embedded settings overlay
  * right after it is shown.
@@ -43,6 +52,8 @@ export interface WorkbenchSettingsInitPayload {
 export interface RendererNotifier {
     /** Broadcast project compile status transitions to the main renderer. */
     projectStatus(payload: ProjectStatusPayload): void;
+    /** Push one per-line dmcc compile-log entry to the main renderer. */
+    compileLog(payload: CompileLogPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */
     windowNavigateBack(): void;
     /** Tell the main renderer the compile popover has been closed. */
@@ -54,6 +65,10 @@ export interface RendererNotifier {
      * placeholder div resizes (closes the host-toolbar dynamic-height loop).
      */
     hostToolbarHeightChanged(height: number): void;
+    /** Ask the main renderer to re-fetch the host-provided header avatar DTO. */
+    headerAvatarChanged(): void;
+    /** Ask the main renderer to re-fetch the host-provided header actions. */
+    headerActionsChanged(): 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.

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

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, AppChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -24,6 +24,9 @@ export function createRendererNotifier(ctx) {
         projectStatus(payload) {
             sendToMain(ProjectChannel.Status, payload);
         },
+        compileLog(payload) {
+            sendToMain(ProjectChannel.CompileLog, payload);
+        },
         windowNavigateBack() {
             sendToMain(WindowChannel.NavigateBack);
         },
@@ -36,6 +39,12 @@ export function createRendererNotifier(ctx) {
         hostToolbarHeightChanged(height) {
             sendToMain(ViewChannel.HostToolbarHeightChanged, height);
         },
+        headerAvatarChanged() {
+            sendToMain(AppChannel.HeaderAvatarChanged);
+        },
+        headerActionsChanged() {
+            sendToMain(AppChannel.HeaderActionsChanged);
+        },
         editorOpenFile(payload) {
             sendToMain(EditorChannel.OpenFile, payload);
         },

package/dist/main/services/views/view-manager.d.ts

@@ -112,6 +112,16 @@ export interface ViewManager {
      * must trust its id — see `createWorkbenchSenderPolicy`.
      */
     getHostToolbarWebContentsId(): number | null;
+    /**
+     * Return the last host-toolbar height NOTIFIED to the main-window renderer
+     * (an advertiser report in `'auto'` mode, a `setHeightMode({ fixed })` pin,
+     * or 0 after `hostToolbar.hide()`); 0 before any notify. The renderer pulls
+     * this on project-view mount to REPLAY a height whose push it missed — the
+     * toolbar's size-advertiser deduplicates and never re-reports, so a notify
+     * fired while no project view is mounted (cold start on the project list;
+     * always on close-project → reopen) would otherwise be lost forever.
+     */
+    getHostToolbarHeight(): number;
     /**
      * NATIVE-HOST ONLY. Position the simulator content WebContentsView over the
      * renderer-measured simulator panel REGION rect (the flex:1 placeholder slot,
@@ -168,10 +178,12 @@ export interface ViewManager {
     }): void;
     /**
      * Reverse size-advertiser sink: the toolbar WCV's own renderer advertises
-     * its intrinsic content height (block-axis extent); we store it and push it
-     * to the main-window renderer so the placeholder div resizes (closing the
-     * dynamic-height loop). Ignored while a `{ fixed }` height mode is pinned
-     * via `hostToolbar.setHeightMode` (the session-resident advertiser always
+     * its intrinsic content height (block-axis extent); we retain it as the
+     * last-notified height (`getHostToolbarHeight`) and push it to the
+     * main-window renderer so the placeholder div resizes (closing the
+     * dynamic-height loop). Ignored ENTIRELY while a `{ fixed }` height mode is
+     * pinned via `hostToolbar.setHeightMode` — dropped reports neither notify
+     * nor touch the retained value (the session-resident advertiser always
      * runs, so its reports must not fight a host-pinned height).
      */
     setHostToolbarHeight(extent: number): void;

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

@@ -95,6 +95,13 @@ export function createViewManager(ctx) {
     // Placeholder height authority: 'auto' = advertiser reports forward to the
     // renderer; { fixed } = host-pinned, advertiser reports are dropped.
     let hostToolbarHeightMode = 'auto';
+    // Last toolbar height NOTIFIED to the main-window renderer — the replay
+    // source behind `getHostToolbarHeight()`. Updated ONLY inside
+    // `notifyHostToolbarHeight` so the retained value can never diverge from
+    // what the renderer was told (an advertiser report dropped by a `{ fixed }`
+    // pin must not pollute it, and a setHeightMode validation reject leaves it
+    // untouched).
+    let hostToolbarLastHeight = 0;
     // Gated narrow channel to the toolbar PAGE (per-load MessagePort handshake;
     // see host-toolbar-port-channel.ts). Control-level registry — created with
     // the manager so onMessage() works before any toolbar view exists.
@@ -248,18 +255,30 @@ export function createViewManager(ctx) {
         }
         view.setBounds(bounds);
     }
+    // Single funnel for the height notify: retain-then-push, so the retained
+    // value is exactly the last value the renderer was told. Every height
+    // notify site MUST go through here — the renderer pulls the retained value
+    // on project-view mount to replay a push it missed (the toolbar's
+    // size-advertiser deduplicates and never re-reports).
+    function notifyHostToolbarHeight(height) {
+        hostToolbarLastHeight = height;
+        ctx.notify.hostToolbarHeightChanged(height);
+    }
     function setHostToolbarHeight(extent) {
         // While the host pins a fixed height, drop advertiser reports entirely —
         // the session-resident advertiser is always installed, so forwarding its
         // reports would make the strip oscillate between the pinned and measured
-        // heights on every content resize.
+        // heights on every content resize. Dropped reports must not touch the
+        // retained value either: retention records what was NOTIFIED, not what
+        // was reported.
         if (hostToolbarHeightMode !== 'auto')
             return;
         // Push the reserved height back to the main-window renderer so its
-        // placeholder div resizes (closing the dynamic-height loop). The height is
-        // not retained in main — the renderer placeholder is the single source of
-        // truth, and the forward anchor re-reports bounds from it.
-        ctx.notify.hostToolbarHeightChanged(extent);
+        // placeholder div resizes (closing the dynamic-height loop). The notified
+        // height IS retained in main (`getHostToolbarHeight`) so a renderer that
+        // mounts later can pull/replay it; the renderer placeholder remains the
+        // geometry authority — the forward anchor re-reports bounds from it.
+        notifyHostToolbarHeight(extent);
     }
     function hideHostToolbar() {
         if (hostToolbarView && hostToolbarViewAdded && !ctx.windows.mainWindow.isDestroyed()) {
@@ -273,7 +292,9 @@ export function createViewManager(ctx) {
         // non-zero reserved height and re-publishes bounds on the next window
         // resize, silently re-adding the view we just hid (unstable hide). Zeroing
         // the height flips the anchor to `present:false` so it stops re-publishing.
-        ctx.notify.hostToolbarHeightChanged(0);
+        // Through the funnel so the retained value follows to 0 — a renderer
+        // mounting after the hide must replay 0, not the stale pre-hide height.
+        notifyHostToolbarHeight(0);
     }
     const hostToolbar = {
         async loadURL(url) {
@@ -317,11 +338,13 @@ export function createViewManager(ctx) {
             if (mode !== 'auto') {
                 // Pin immediately: a preload-less/static toolbar never advertises, so
                 // waiting for the next report would leave the strip at height 0.
-                ctx.notify.hostToolbarHeightChanged(mode.fixed);
+                notifyHostToolbarHeight(mode.fixed);
             }
             // Switching back to 'auto' deliberately does NOT synthesize a notify —
             // replaying a stale cached height would flash the old size; the NEXT
-            // advertiser report drives the placeholder again.
+            // advertiser report drives the placeholder again. The RETAINED value
+            // survives the switch though: a freshly-mounting renderer still needs
+            // the pinned height until that next report lands.
         },
         onMessage(channel, handler) {
             return hostToolbarPort.onMessage(channel, handler);
@@ -1146,6 +1169,7 @@ export function createViewManager(ctx) {
             return popoverView.webContents.id;
         },
         getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
+        getHostToolbarHeight: () => hostToolbarLastHeight,
         setNativeSimulatorViewBounds,
         resize,
         setSimulatorDevtoolsBounds,

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

@@ -1,5 +1,5 @@
 import type { BrowserWindow } from 'electron';
-import type { CompilationAdapter, WorkbenchConfig } from '../../shared/types.js';
+import type { CompilationAdapter, HeaderActionsProvider, HeaderAvatarProvider, WorkbenchConfig } from '../../shared/types.js';
 import type { BridgeRouterHandle } from '../ipc/bridge-router.js';
 import type { ConsoleForwarder } from './console-forward/index.js';
 import type { NetworkForwarder } from './network-forward/index.js';
@@ -35,6 +35,14 @@ export interface WorkbenchContext {
     }> | {
         appName: string;
     };
+    /** Host-injected profile provider for the built-in header avatar slot. */
+    headerAvatarProvider?: HeaderAvatarProvider;
+    /** Host-injected click handler for the built-in header avatar slot. */
+    headerAvatarActionHandler?: () => void | Promise<void>;
+    /** Host-injected compact action provider for the built-in project header. */
+    headerActionsProvider?: HeaderActionsProvider;
+    /** Host-injected click handler for the built-in project header actions. */
+    headerActionHandler?: (id: string) => void | Promise<void>;
     /** Unified lifecycle manager for all overlay WebContentsViews */
     views: ViewManager;
     /** Owns BrowserWindow instances (main + settings) and their sender-id checks. */
@@ -175,6 +183,10 @@ export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' |
     preloadPath: string;
     rendererDir: string;
     brandingProvider?: WorkbenchContext['brandingProvider'];
+    headerAvatarProvider?: WorkbenchContext['headerAvatarProvider'];
+    headerAvatarActionHandler?: WorkbenchContext['headerAvatarActionHandler'];
+    headerActionsProvider?: WorkbenchContext['headerActionsProvider'];
+    headerActionHandler?: WorkbenchContext['headerActionHandler'];
     /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
     projectsProvider?: ProjectsProvider;
     /** Templates injected by the host; same-id overrides a built-in. */

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

@@ -18,6 +18,10 @@ export function createWorkbenchContext(opts) {
         apiNamespaces: opts.apiNamespaces ?? [],
         appName: opts.appName ?? 'Dimina DevTools',
         brandingProvider: opts.brandingProvider,
+        headerAvatarProvider: opts.headerAvatarProvider,
+        headerAvatarActionHandler: opts.headerAvatarActionHandler,
+        headerActionsProvider: opts.headerActionsProvider,
+        headerActionHandler: opts.headerActionHandler,
     };
     ctx.registry = new DisposableRegistry();
     // Empty connection registry as a first-class context field. Connections are

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

@@ -18,6 +18,16 @@ export function createWorkspaceService(ctx) {
     // accept an in-flight write that targets the just-closed project. Reset at
     // the start of every `openProject` so it never accumulates a stale root.
     let lastClosedProjectPath = '';
+    // Session generation for the onLog closure handed to the adapter: a closed
+    // (or switched-away-from) session's compile worker dies asynchronously, so
+    // buffered log lines can still arrive through the OLD closure after
+    // closeProject/openProject. Each openProject claims a new generation and
+    // closeProject invalidates the current one; a stale closure sees the
+    // mismatch and drops the line instead of polluting the next project's
+    // compile panel. (Deliberately NOT a `currentSession !== null` check: the
+    // first compile's log lines arrive while the adapter promise is still
+    // pending, before currentSession is assigned.)
+    let logGeneration = 0;
     function sendStatus(status, message, hotReload) {
         ctx.notify.projectStatus(hotReload ? { status, message, hotReload: true } : { status, message });
     }
@@ -71,6 +81,14 @@ export function createWorkspaceService(ctx) {
             : null,
         async openProject(projectPath) {
             clearSimulatorServicewechatReferer();
+            // Invalidate the outgoing session's onLog BEFORE teardown starts (same
+            // order as closeProject below): the dying compile worker flushes
+            // buffered lines DURING disposeSession(), and with the old generation
+            // still current they would pass the staleness guard and pollute the
+            // incoming project's compile-log timeline. The new session claims its
+            // own fresh generation further down (after dispose), so its onLog
+            // forwards normally.
+            logGeneration++;
             await disposeSession();
             currentProjectPath = '';
             // A fresh open starts a clean sandbox window — drop any previously
@@ -92,6 +110,9 @@ export function createWorkspaceService(ctx) {
             }
             sendStatus('compiling', '正在编译...');
             const { compile } = loadWorkbenchSettings();
+            // This open owns the log channel until the next open/close bumps the
+            // generation — the onLog closure below checks it per line.
+            const sessionGeneration = ++logGeneration;
             let session;
             try {
                 session = await ctx.adapter.openProject({
@@ -100,6 +121,21 @@ export function createWorkspaceService(ctx) {
                     watch: compile.watch,
                     onRebuild: () => sendStatus('ready', '编译完成，已热更新', true),
                     onBuildError: (err) => sendStatus('error', String(err)),
+                    // Per-line dmcc log (already filtered in devkit). Stamp the
+                    // wall-clock capture time here and push verbatim on the dedicated
+                    // compile-log channel — never through projectStatus, whose
+                    // one-event-per-payload contract feeds compileEvents. Stale lines
+                    // (a closed/replaced session's worker flushing its buffers) are
+                    // dropped via the generation check.
+                    onLog: (entry) => {
+                        if (sessionGeneration !== logGeneration)
+                            return;
+                        ctx.notify.compileLog({
+                            stream: entry.stream,
+                            text: entry.text,
+                            at: Date.now(),
+                        });
+                    },
                 });
             }
             catch (err) {
@@ -141,6 +177,9 @@ export function createWorkspaceService(ctx) {
             };
         },
         async closeProject() {
+            // Invalidate the active session's onLog BEFORE teardown starts — lines
+            // flushed by the dying compile worker must not reach the panel.
+            logGeneration++;
             clearSimulatorServicewechatReferer();
             await disposeSession();
             // Record the root being torn down BEFORE clearing it, so a teardown/

package/dist/preload/index.d.ts

@@ -13,7 +13,7 @@ export { installConsoleInstrumentation } from './instrumentation/console.js';
 export { createAppDataSource } from './instrumentation/app-data.js';
 export type { AppDataSnapshot } from './instrumentation/app-data.js';
 /**
- * @deprecated Will be removed in the next minor. Under the native-host (sole)
+ * @deprecated Will be removed in 0.5.0. Under the native-host (sole)
  * runtime the simulator top frame is a top-level WebContentsView — the page DOM
  * lives in child render-host `<webview>` guests, so this top-frame DOM observer
  * only ever publishes `null`. Panel WXML flows over the main-process
@@ -21,7 +21,7 @@ export type { AppDataSnapshot } from './instrumentation/app-data.js';
  */
 export { createWxmlSource } from './instrumentation/wxml.js';
 /**
- * @deprecated Will be removed in the next minor. The host's
+ * @deprecated Will be removed in 0.5.0. The host's
  * `miniapp-snapshot:push/pull` IPC has no receiving end under the native-host
  * (sole) runtime: the simulator is a top-level WebContentsView without an
  * embedder (its `sendToHost` fires into the void) and the renderer-side puller

package/dist/preload/index.js

@@ -12,7 +12,7 @@
 export { installConsoleInstrumentation } from './instrumentation/console.js';
 export { createAppDataSource } from './instrumentation/app-data.js';
 /**
- * @deprecated Will be removed in the next minor. Under the native-host (sole)
+ * @deprecated Will be removed in 0.5.0. Under the native-host (sole)
  * runtime the simulator top frame is a top-level WebContentsView — the page DOM
  * lives in child render-host `<webview>` guests, so this top-frame DOM observer
  * only ever publishes `null`. Panel WXML flows over the main-process
@@ -20,7 +20,7 @@ export { createAppDataSource } from './instrumentation/app-data.js';
  */
 export { createWxmlSource } from './instrumentation/wxml.js';
 /**
- * @deprecated Will be removed in the next minor. The host's
+ * @deprecated Will be removed in 0.5.0. The host's
  * `miniapp-snapshot:push/pull` IPC has no receiving end under the native-host
  * (sole) runtime: the simulator is a top-level WebContentsView without an
  * embedder (its `sendToHost` fires into the void) and the renderer-side puller

package/dist/preload/windows/host-toolbar-runtime.cjs

@@ -134,7 +134,17 @@ var ViewChannel = {
    * main → main-window renderer: push the reserved host-toolbar height so the
    * renderer placeholder div resizes (closing the dynamic-height loop).
    */
-  HostToolbarHeightChanged: "view:host-toolbar:height-changed"
+  HostToolbarHeightChanged: "view:host-toolbar:height-changed",
+  /**
+   * main ← main-window renderer (invoke): pull the last NOTIFIED toolbar
+   * height retained in main. Mount-time replay companion to
+   * `HostToolbarHeightChanged`: the push listener mounts with the project
+   * view and the toolbar's size-advertiser deduplicates (never re-reports),
+   * so a height pushed while no project view was mounted would otherwise be
+   * lost forever (cold start on the project list races it; close-project →
+   * reopen hits it deterministically). No payload; resolves a number.
+   */
+  HostToolbarGetHeight: "view:host-toolbar:get-height"
 };
 
 // src/preload/runtime/host-toolbar-advertiser.ts