@dimina-kit/devtools 0.3.2-dev.20260522110734 → 0.3.2-dev.20260522142649

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

@@ -1,11 +1,13 @@
 import type { BrowserWindow } from 'electron';
-import type { CompilationAdapter } from '../../shared/types.js';
+import type { CompilationAdapter, WorkbenchConfig } 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 { type SimulatorApiRegistry } from './simulator/custom-apis.js';
+import { type ToolbarStore } from './toolbar/toolbar-store.js';
 import { sanitizeTemplates } from './projects/templates.js';
 import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
 import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
@@ -25,14 +27,8 @@ export interface WorkbenchContext {
     apiNamespaces: string[];
     /** Branding name shown in title bar and getBranding IPC */
     appName: string;
-    /** Host-injected provider for toolbar actions (overrides default empty list) */
-    toolbarActions?: () => Promise<Array<{
-        id: string;
-        label: string;
-    }>> | Array<{
-        id: string;
-        label: string;
-    }>;
+    /** Header bar height in px, used for view layout and exposed to the renderer */
+    headerHeight: number;
     /** Host-injected provider for branding info (overrides default appName) */
     brandingProvider?: () => Promise<{
         appName: string;
@@ -77,18 +73,48 @@ export interface WorkbenchContext {
      * lazily so it stays correct as windows/views come and go.
      */
     senderPolicy: SenderPolicy;
+    /**
+     * Reference-counted map of `webContents.id` → live registration count for
+     * host-owned BrowserWindows registered as trusted senders via
+     * `instance.registerTrustedWindow`. A window stays trusted while its count
+     * is > 0; registering the same window N times requires N disposals (or a
+     * single `closed` event, which zeroes the count outright) to un-trust it.
+     * Consulted by `createWorkbenchSenderPolicy` in addition to the static
+     * main-window / overlay checks.
+     */
+    trustedWindowSenderIds: Map<number, number>;
+    /**
+     * Per-context registry of host-registered simulator custom APIs. Populated
+     * via `instance.registerSimulatorApi`; read by the simulator IPC handlers.
+     * One registry per context — no process-global crosstalk.
+     */
+    simulatorApis: SimulatorApiRegistry;
+    /**
+     * Per-context store of host-registered toolbar actions. Populated via
+     * `instance.toolbar.set`; read by the toolbar IPC handlers. One store per
+     * context — no process-global crosstalk.
+     */
+    toolbar: ToolbarStore;
     /** Aggregates dispose handlers for every IPC handler, listener, watcher, and CDP session registered by the workbench. */
     registry: DisposableRegistry;
 }
-export interface CreateContextOptions {
+/**
+ * Inputs for `createWorkbenchContext`. The scalar config fields it shares with
+ * `WorkbenchConfig` (`adapter` / `apiNamespaces` / `appName` / `headerHeight`)
+ * are derived from there via `Pick` so the two stay in lockstep — no
+ * field-by-field re-declaration. The remaining fields are kept explicit
+ * because their shapes intentionally differ from the config:
+ *  - `preloadPath` / `rendererDir` are REQUIRED here (the caller resolves the
+ *    defaults before constructing the context) but optional in the config;
+ *  - `panels` is the structural `string[]` (the context stores raw ids);
+ *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
+ *    the main-process types, not the structural mirrors in `shared/types`.
+ */
+export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'headerHeight'> {
     mainWindow: BrowserWindow;
-    adapter?: CompilationAdapter;
     preloadPath: string;
     rendererDir: string;
     panels?: string[];
-    apiNamespaces?: string[];
-    appName?: string;
-    toolbarActions?: WorkbenchContext['toolbarActions'];
     brandingProvider?: WorkbenchContext['brandingProvider'];
     /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
     projectsProvider?: ProjectsProvider;

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

@@ -6,6 +6,8 @@ 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 { createSimulatorApiRegistry, } from './simulator/custom-apis.js';
+import { createToolbarStore } from './toolbar/toolbar-store.js';
 import { resolveTemplates, sanitizeTemplates } from './projects/templates.js';
 import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
 export function hasBuiltinPanel(ctx, panelId) {
@@ -26,10 +28,13 @@ export function createWorkbenchContext(opts) {
         panels: opts.panels ?? ['wxml', 'console', 'appdata', 'storage'],
         apiNamespaces: opts.apiNamespaces ?? [],
         appName: opts.appName ?? 'Dimina DevTools',
-        toolbarActions: opts.toolbarActions,
+        headerHeight: opts.headerHeight ?? 40,
         brandingProvider: opts.brandingProvider,
     };
     ctx.registry = new DisposableRegistry();
+    ctx.trustedWindowSenderIds = new Map();
+    ctx.simulatorApis = createSimulatorApiRegistry();
+    ctx.toolbar = createToolbarStore();
     ctx.windows = createWindowService(opts.mainWindow);
     ctx.views = createViewManager(ctx);
     ctx.notify = createRendererNotifier(ctx);

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

@@ -6,6 +6,11 @@ export declare function toDisposable(fn: DisposeFn): Disposable;
 export declare class DisposableRegistry implements Disposable {
     private entries;
     private _disposed;
+    /**
+     * Number of live entries. A wrapper's `dispose` splices its entry out and
+     * `disposeAll` clears the array, so `entries.length` is the live count.
+     */
+    get size(): number;
     add(d: Disposable | DisposeFn): Disposable;
     disposeAll(): Promise<void>;
     dispose(): Promise<void>;

package/dist/main/utils/disposable.js

@@ -12,6 +12,13 @@ export function toDisposable(fn) {
 export class DisposableRegistry {
     entries = [];
     _disposed = false;
+    /**
+     * Number of live entries. A wrapper's `dispose` splices its entry out and
+     * `disposeAll` clears the array, so `entries.length` is the live count.
+     */
+    get size() {
+        return this.entries.length;
+    }
     add(d) {
         if (this._disposed) {
             throw new Error('cannot add to disposed registry');

package/dist/main/utils/ipc-registry.js

@@ -55,8 +55,12 @@ export class IpcRegistry {
     }
     handle(channel, fn) {
         const policy = this.policy;
+        // The gate is `async` so a rejected sender surfaces as a *rejected
+        // promise* (the invoke-result contract) rather than a synchronous throw —
+        // synchronous throws can escape callers that wrap the result in
+        // `Promise.resolve(...)` instead of `await`-ing it directly.
         const guarded = policy
-            ? (event, ...args) => {
+            ? async (event, ...args) => {
                 const sender = event.sender;
                 if (!policy(sender)) {
                     console.warn(`[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`);

package/dist/main/utils/sender-policy.d.ts

@@ -18,8 +18,11 @@ import type { SenderPolicy } from './ipc-registry.js';
  * Keeping the guest off this list contains the blast radius if the
  * simulator content is ever compromised.
  *
+ * Host-owned BrowserWindows registered via `instance.registerTrustedWindow`
+ * are additionally accepted via `ctx.trustedWindowSenderIds`.
+ *
  * Any other sender — including a stale/destroyed sender or an unknown
  * iframe — is rejected.
  */
-export declare function createWorkbenchSenderPolicy(ctx: Pick<WorkbenchContext, 'windows' | 'views'>): SenderPolicy;
+export declare function createWorkbenchSenderPolicy(ctx: Pick<WorkbenchContext, 'windows' | 'views' | 'trustedWindowSenderIds'>): SenderPolicy;
 //# sourceMappingURL=sender-policy.d.ts.map

package/dist/main/utils/sender-policy.js

@@ -16,6 +16,9 @@
  * Keeping the guest off this list contains the blast radius if the
  * simulator content is ever compromised.
  *
+ * Host-owned BrowserWindows registered via `instance.registerTrustedWindow`
+ * are additionally accepted via `ctx.trustedWindowSenderIds`.
+ *
  * Any other sender — including a stale/destroyed sender or an unknown
  * iframe — is rejected.
  */
@@ -29,6 +32,9 @@ export function createWorkbenchSenderPolicy(ctx) {
         // Standalone settings BrowserWindow renderer
         if (ctx.windows.isSettingsWindowSender(sender.id))
             return true;
+        // Host-registered trusted windows (registerTrustedWindow)
+        if (ctx.trustedWindowSenderIds.has(sender.id))
+            return true;
         // Settings overlay view (mounted inside the main window)
         const settingsViewId = ctx.views.getSettingsWebContentsId();
         if (settingsViewId != null && sender.id === settingsViewId)

package/dist/preload/runtime/custom-apis.js

@@ -1,6 +1,23 @@
 import { ipcRenderer } from 'electron';
 import { SimulatorCustomApiBridgeChannel } from '../../shared/ipc-channels.js';
 import { exposeOnMainWorld } from '../shared/expose.js';
+/**
+ * Re-send interval and ceiling for `list()` (see `listWithRetry`).
+ *
+ * The simulator boots fast enough that `__diminaCustomApis.list()` can fire
+ * its `sendToHost` request *before* the embedding main-window renderer has
+ * attached its `ipc-message` proxy listener (`useCustomApiProxy`). `sendToHost`
+ * is fire-and-forget — a request sent into that gap is lost, and the bridge
+ * call would otherwise hang until `custom-api-boot.ts`'s 3s deadlock-breaker.
+ *
+ * `list` is an idempotent read, so it is safe to re-send until a response
+ * arrives. The retry resolves within one embedder attach cycle (~200ms) in
+ * practice; the ceiling only bounds the leak if the proxy never attaches at
+ * all, and is kept below `custom-api-boot.ts`'s `CUSTOM_API_LIST_TIMEOUT_MS`
+ * so the retry exhausts before — not after — that outer timeout would fire.
+ */
+const LIST_RETRY_INTERVAL_MS = 150;
+const LIST_RETRY_CEILING_MS = 2500;
 // The simulator <webview> is intentionally kept off the workbench sender-policy
 // white-list, so it cannot reach `ipcMain.handle` directly. Instead the bridge
 // asks the trusted main-window renderer to proxy the call: webview sends via
@@ -31,8 +48,62 @@ function buildBridge() {
             ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
         });
     };
+    /**
+     * `list()` with re-send, to survive the embedder proxy attaching after the
+     * first request (see `LIST_RETRY_INTERVAL_MS`). Each attempt uses a fresh id
+     * and its own `pending` entry; whichever response lands first settles the
+     * call. Stale entries for the other attempts are dropped so a late duplicate
+     * response cannot resolve nothing — or, worse, leak.
+     */
+    const listWithRetry = () => {
+        return new Promise((resolve, reject) => {
+            const attemptIds = new Set();
+            // Boxed so `cleanup` (defined before the timers are created) can clear
+            // them; the box itself is `const`, only its fields are assigned later.
+            const state = { settled: false };
+            const cleanup = () => {
+                state.settled = true;
+                if (state.retryTimer)
+                    clearInterval(state.retryTimer);
+                if (state.ceilingTimer)
+                    clearTimeout(state.ceilingTimer);
+                for (const id of attemptIds)
+                    pending.delete(id);
+                attemptIds.clear();
+            };
+            const attempt = () => {
+                if (state.settled)
+                    return;
+                const id = nextId++;
+                attemptIds.add(id);
+                pending.set(id, {
+                    resolve: (value) => {
+                        if (state.settled)
+                            return;
+                        cleanup();
+                        resolve(value);
+                    },
+                    reject: (reason) => {
+                        if (state.settled)
+                            return;
+                        cleanup();
+                        reject(reason);
+                    },
+                });
+                ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, { id, op: 'list' });
+            };
+            state.retryTimer = setInterval(attempt, LIST_RETRY_INTERVAL_MS);
+            state.ceilingTimer = setTimeout(() => {
+                if (state.settled)
+                    return;
+                cleanup();
+                reject(new Error('custom-apis bridge list() got no response from the host renderer'));
+            }, LIST_RETRY_CEILING_MS);
+            attempt();
+        });
+    };
     return {
-        list: () => send({ id: nextId++, op: 'list' }),
+        list: listWithRetry,
         invoke: (name, params) => send({ id: nextId++, op: 'invoke', name, params }),
     };
 }

package/dist/preload/windows/simulator.js

@@ -198,6 +198,8 @@ var MiniappSnapshotChannel = {
 };
 
 // src/preload/runtime/custom-apis.ts
+var LIST_RETRY_INTERVAL_MS = 150;
+var LIST_RETRY_CEILING_MS = 2500;
 function buildBridge() {
   let nextId = 1;
   const pending = /* @__PURE__ */ new Map();
@@ -220,8 +222,46 @@ function buildBridge() {
       import_electron2.ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
     });
   };
+  const listWithRetry = () => {
+    return new Promise((resolve, reject) => {
+      const attemptIds = /* @__PURE__ */ new Set();
+      const state2 = { settled: false };
+      const cleanup = () => {
+        state2.settled = true;
+        if (state2.retryTimer) clearInterval(state2.retryTimer);
+        if (state2.ceilingTimer) clearTimeout(state2.ceilingTimer);
+        for (const id of attemptIds) pending.delete(id);
+        attemptIds.clear();
+      };
+      const attempt = () => {
+        if (state2.settled) return;
+        const id = nextId++;
+        attemptIds.add(id);
+        pending.set(id, {
+          resolve: (value) => {
+            if (state2.settled) return;
+            cleanup();
+            resolve(value);
+          },
+          reject: (reason) => {
+            if (state2.settled) return;
+            cleanup();
+            reject(reason);
+          }
+        });
+        import_electron2.ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, { id, op: "list" });
+      };
+      state2.retryTimer = setInterval(attempt, LIST_RETRY_INTERVAL_MS);
+      state2.ceilingTimer = setTimeout(() => {
+        if (state2.settled) return;
+        cleanup();
+        reject(new Error("custom-apis bridge list() got no response from the host renderer"));
+      }, LIST_RETRY_CEILING_MS);
+      attempt();
+    });
+  };
   return {
-    list: () => send({ id: nextId++, op: "list" }),
+    list: listWithRetry,
     invoke: (name, params) => send({ id: nextId++, op: "invoke", name, params })
   };
 }