@dimina-kit/devtools 0.3.2-dev.20260611135124 → 0.4.0-dev.20260612152115

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

@@ -41,6 +41,13 @@ export interface WorkbenchContext {
     windows: WindowService;
     /** Unified main → renderer event dispatcher */
     notify: RendererNotifier;
+    /**
+     * Open (or re-focus) the standalone workbench-settings window. First-class
+     * member so contract holders (`MiniappRuntime` / `MenuContext`) can open
+     * settings without reaching into `windows`/`notify` plumbing. Wired by
+     * `createWorkbenchContext` to the real `openSettingsWindow` path.
+     */
+    openSettings: () => Promise<void>;
     /** Single source of truth for project + session + per-project settings */
     workspace: WorkspaceService;
     /**

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

@@ -4,6 +4,7 @@ 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 { openSettingsWindow } from '../windows/settings-window/index.js';
 import { createWorkspaceService, } from './workspace/workspace-service.js';
 import { createLocalProjectsProvider } from './projects/local-provider.js';
 import { createSimulatorApiRegistry, } from './simulator/custom-apis.js';
@@ -29,6 +30,10 @@ export function createWorkbenchContext(opts) {
     ctx.windows = createWindowService(opts.mainWindow);
     ctx.views = createViewManager(ctx);
     ctx.notify = createRendererNotifier(ctx);
+    // Lazy closure (not a bound snapshot): reads ctx.windows/notify/rendererDir
+    // at call time through the live context, which structurally satisfies the
+    // helper's narrow OpenSettingsWindowDeps.
+    ctx.openSettings = () => openSettingsWindow(ctx);
     ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
     ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
     ctx.customCreateProjectDialog = opts.customCreateProjectDialog;

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

@@ -1,4 +1,4 @@
-import type { CompileConfig } from '../../../shared/types.js';
+import type { AppInfo, CompileConfig, ProjectSession } from '../../../shared/types.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 import type { Project, ProjectPages, ProjectSettings } from '../projects/project-repository.js';
 /**
@@ -9,7 +9,7 @@ import type { Project, ProjectPages, ProjectSettings } from '../projects/project
 export interface OpenProjectResult {
     success: boolean;
     port?: number;
-    appInfo?: unknown;
+    appInfo?: AppInfo;
     error?: string;
 }
 /**
@@ -32,11 +32,7 @@ export interface WorkspaceService {
     validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;
     closeProject(): Promise<void>;
-    getSession(): {
-        close: () => Promise<void>;
-        port: number;
-        appInfo: unknown;
-    } | null;
+    getSession(): ProjectSession | null;
     getProjectPath(): string;
     /**
      * The project path most recently torn down by `closeProject`, or '' if none

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

@@ -1,7 +1,15 @@
+import { z } from 'zod';
 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';
+/**
+ * Runtime guard for the adapter-return boundary: `session.appInfo` must be an
+ * object carrying a string `appId` (the renderer derives its IPC scoping from
+ * it; a session without one cannot be driven). Loose: extra fields pass
+ * through untouched — only the contract-critical `appId` is enforced.
+ */
+const SessionAppInfoSchema = z.looseObject({ appId: z.string() });
 /** Build a workspace service bound to the given workbench context. */
 export function createWorkspaceService(ctx) {
     let currentSession = null;
@@ -10,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 });
     }
@@ -63,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
@@ -84,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({
@@ -92,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) {
@@ -99,6 +143,25 @@ export function createWorkspaceService(ctx) {
                 sendStatus('error', String(err));
                 return { success: false, error: String(err) };
             }
+            // Adapter-return boundary: enforce the AppInfo producer contract the
+            // moment the adapter resolves, BEFORE the session is recorded. A
+            // session without a string appId cannot be driven by the renderer, so
+            // it must never become the active session. The adapter already spun up
+            // live resources (compile watcher, dev-server port) — close them
+            // best-effort before reporting; the validation report is the law and a
+            // failing close() must not mask it (or escape as a throw).
+            if (!SessionAppInfoSchema.safeParse(session.appInfo).success) {
+                try {
+                    await session.close();
+                }
+                catch (closeErr) {
+                    console.warn('[workspace] closing appId-less adapter session failed (non-fatal):', closeErr);
+                }
+                const error = 'adapter returned session.appInfo without a string appId — ' +
+                    'the CompilationAdapter must supply appInfo.appId';
+                sendStatus('error', error);
+                return { success: false, error };
+            }
             currentSession = session;
             currentProjectPath = projectPath;
             bestEffort('updateLastOpened', () => {
@@ -114,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/main/windows/settings-window/index.d.ts

@@ -1,3 +1,36 @@
+import type { BrowserWindow } from 'electron';
+import { type WorkbenchSettings } from '../../services/settings/index.js';
 export { createSettingsWindow } from './create.js';
 export { wireSettingsWindowEvents } from './events.js';
+/**
+ * Exactly what `openSettingsWindow` needs — its OWN narrow deps interface,
+ * not a `Pick<WorkbenchContext, …>`: picking from the full context couples
+ * this helper to the whole context type (and made the contract's old
+ * `windows: object` pass-through promise unfulfillable). A full
+ * `WorkbenchContext` satisfies this structurally, so assembly points pass
+ * the context straight through.
+ */
+export interface OpenSettingsWindowDeps {
+    /** Absolute path to the renderer dist directory (settings entry HTML). */
+    rendererDir: string;
+    windows: {
+        readonly mainWindow: BrowserWindow;
+        readonly settingsWindow: BrowserWindow | null;
+        setSettingsWindow(win: BrowserWindow | null): void;
+    };
+    notify: {
+        workbenchSettingsInit(window: BrowserWindow, payload: {
+            settings: WorkbenchSettings;
+        }): void;
+    };
+}
+/**
+ * Open (or re-focus) the standalone workbench-settings window. Reuses the
+ * live window when one is already registered; otherwise creates it, registers
+ * it on the window service, and wires its `closed` cleanup. Concurrent calls
+ * share a single in-flight creation (exactly one window; every caller still
+ * gets the show/focus/snapshot semantics). Always shows + focuses, then
+ * pushes the current settings snapshot into it.
+ */
+export declare function openSettingsWindow(deps: OpenSettingsWindowDeps): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/windows/settings-window/index.js

@@ -1,3 +1,62 @@
+import { createSettingsWindow } from './create.js';
+import { wireSettingsWindowEvents } from './events.js';
+import { loadWorkbenchSettings, } from '../../services/settings/index.js';
 export { createSettingsWindow } from './create.js';
 export { wireSettingsWindowEvents } from './events.js';
+/**
+ * In-flight creation guard, keyed by the windows registry (the identity that
+ * owns the `settingsWindow` slot). Overlapping `openSettingsWindow` calls
+ * before the first creation lands must share ONE creation — without this,
+ * both observe `settingsWindow === null` across the async construction
+ * boundary, build two BrowserWindows, and the loser is orphaned (alive,
+ * unreachable, never reused).
+ */
+const inFlightCreations = new WeakMap();
+async function getOrCreateSettingsWindow(deps) {
+    const existing = deps.windows.settingsWindow;
+    if (existing && !existing.isDestroyed())
+        return existing;
+    const inFlight = inFlightCreations.get(deps.windows);
+    if (inFlight)
+        return inFlight;
+    const creation = (async () => {
+        const win = await createSettingsWindow(deps.windows.mainWindow, deps.rendererDir);
+        deps.windows.setSettingsWindow(win);
+        wireSettingsWindowEvents(win, () => {
+            // Electron delivers 'closed' asynchronously: a just-destroyed window's
+            // late callback may arrive AFTER a successor was registered. Only the
+            // CURRENT registration's own close may clear the slot — a stale
+            // window's close must not drop a live successor.
+            if (deps.windows.settingsWindow === win) {
+                deps.windows.setSettingsWindow(null);
+            }
+        });
+        return win;
+    })();
+    inFlightCreations.set(deps.windows, creation);
+    try {
+        return await creation;
+    }
+    finally {
+        if (inFlightCreations.get(deps.windows) === creation) {
+            inFlightCreations.delete(deps.windows);
+        }
+    }
+}
+/**
+ * Open (or re-focus) the standalone workbench-settings window. Reuses the
+ * live window when one is already registered; otherwise creates it, registers
+ * it on the window service, and wires its `closed` cleanup. Concurrent calls
+ * share a single in-flight creation (exactly one window; every caller still
+ * gets the show/focus/snapshot semantics). Always shows + focuses, then
+ * pushes the current settings snapshot into it.
+ */
+export async function openSettingsWindow(deps) {
+    const win = await getOrCreateSettingsWindow(deps);
+    win.show();
+    win.focus();
+    deps.notify.workbenchSettingsInit(win, {
+        settings: loadWorkbenchSettings(),
+    });
+}
 //# sourceMappingURL=index.js.map

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/runtime/host-toolbar-port.d.ts

@@ -1,6 +1,16 @@
 /**
  * Preload side of the host-toolbar gated narrow channel.
  *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostToolbar` is a published page-facing API, typed by the
+ * exported `DiminaHostToolbarPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host toolbar pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
  * Receives the per-load MessagePort main transfers on `did-finish-load`
  * (`ViewChannel.HostToolbarPort`, `event.ports[0]`) and bridges it to the page
  * as `window.diminaHostToolbar` — EXACTLY `{ send, onMessage }`, functions
@@ -35,10 +45,5 @@
  * envelope (queued first-comers survive), one console.warn per load.
  */
 export declare const HOST_TOOLBAR_PENDING_LIMIT = 128;
-/**
- * Subscribe the handshake channel and expose the page bridge. Call ONLY from
- * a passing toolbar-runtime guard (`activateHostToolbarRuntime`) — a failing
- * guard must leave zero footprint (no bridge key, no IPC listener).
- */
 export declare function installHostToolbarPortBridge(): void;
 //# sourceMappingURL=host-toolbar-port.d.ts.map

package/dist/preload/runtime/host-toolbar-port.js

@@ -1,6 +1,16 @@
 /**
  * Preload side of the host-toolbar gated narrow channel.
  *
+ * ── PUBLIC SURFACE EVOLUTION RULE ───────────────────────────────────────────
+ * `window.diminaHostToolbar` is a published page-facing API, typed by the
+ * exported `DiminaHostToolbarPageBridge` (src/main/runtime/miniapp-runtime.ts)
+ * — arbitrary host toolbar pages compile against it. Members may only be
+ * ADDED, never changed: any semantic change to an existing member (signature,
+ * return shape, queueing/throw behavior) ships under a NEW name instead.
+ * Exception: security fixes / compliance corrections may change existing
+ * member semantics, and MUST be called out in the release's version notes.
+ * Keep the exported bridge type in lockstep with what is exposed here.
+ *
  * Receives the per-load MessagePort main transfers on `did-finish-load`
  * (`ViewChannel.HostToolbarPort`, `event.ports[0]`) and bridges it to the page
  * as `window.diminaHostToolbar` — EXACTLY `{ send, onMessage }`, functions
@@ -43,6 +53,18 @@ export const HOST_TOOLBAR_PENDING_LIMIT = 128;
  * a passing toolbar-runtime guard (`activateHostToolbarRuntime`) — a failing
  * guard must leave zero footprint (no bridge key, no IPC listener).
  */
+/**
+ * Entry-waist channel validation, parity with the main side's
+ * `hostToolbar.onMessage` guard (same TypeError, message names `channel`).
+ * Runs BEFORE any state is touched (no queue slot, no registry entry), in
+ * both port states — a page author's typo throws at the call site instead of
+ * vanishing into main's silent inbound drop.
+ */
+function assertValidChannel(method, channel) {
+    if (typeof channel !== 'string' || channel === '') {
+        throw new TypeError(`diminaHostToolbar.${method}: channel must be a non-empty string`);
+    }
+}
 export function installHostToolbarPortBridge() {
     let activePort = null;
     const pending = [];
@@ -96,6 +118,7 @@ export function installHostToolbarPortBridge() {
     // isolated world.
     contextBridge.exposeInMainWorld(BRIDGE_KEY, {
         send(channel, payload) {
+            assertValidChannel('send', channel);
             const envelope = { channel, payload };
             if (activePort) {
                 activePort.postMessage(envelope);
@@ -114,6 +137,7 @@ export function installHostToolbarPortBridge() {
             pending.push(envelope);
         },
         onMessage(channel, handler) {
+            assertValidChannel('onMessage', channel);
             const entry = { channel, handler };
             handlers.push(entry);
             return () => {

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
@@ -173,6 +183,13 @@ function installHostToolbarAdvertiserWhenReady() {
 var import_electron2 = require("electron");
 var BRIDGE_KEY = "diminaHostToolbar";
 var HOST_TOOLBAR_PENDING_LIMIT = 128;
+function assertValidChannel(method, channel) {
+  if (typeof channel !== "string" || channel === "") {
+    throw new TypeError(
+      `diminaHostToolbar.${method}: channel must be a non-empty string`
+    );
+  }
+}
 function installHostToolbarPortBridge() {
   let activePort = null;
   const pending = [];
@@ -209,6 +226,7 @@ function installHostToolbarPortBridge() {
   });
   import_electron2.contextBridge.exposeInMainWorld(BRIDGE_KEY, {
     send(channel, payload) {
+      assertValidChannel("send", channel);
       const envelope = { channel, payload };
       if (activePort) {
         activePort.postMessage(envelope);
@@ -226,6 +244,7 @@ function installHostToolbarPortBridge() {
       pending.push(envelope);
     },
     onMessage(channel, handler) {
+      assertValidChannel("onMessage", channel);
       const entry = { channel, handler };
       handlers.push(entry);
       return () => {