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

package/dist/main/services/automation/exec.js

@@ -1,13 +1,8 @@
-import { webContents } from 'electron';
 // ── Helpers ───────────────────────────────────────────────────────────
 export function getSimulator(ctx) {
-    const simWcId = ctx.views.getSimulatorWebContentsId();
-    if (!ctx.workspace.hasActiveSession() || simWcId == null)
+    if (!ctx.workspace.hasActiveSession())
         return null;
-    const sim = webContents.fromId(simWcId);
-    if (!sim || sim.isDestroyed())
-        return null;
-    return sim;
+    return ctx.views.getSimulatorWebContents();
 }
 export async function evalInSim(ctx, expression) {
     const sim = getSimulator(ctx);
@@ -17,8 +12,11 @@ export async function evalInSim(ctx, expression) {
 }
 /** Build JS that locates an element by selector+index inside the active page iframe. */
 export function buildElAccess(ref, varName = 'el') {
-    const escaped = ref.selector.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-    return `const ${varName} = _doc.querySelectorAll('${escaped}')[${ref.index}]`;
+    return `const ${varName} = _doc.querySelectorAll(${JSON.stringify(ref.selector)})[${ref.index}]`;
+}
+/** Run `body` inside the active page iframe with `varName` bound to the element at `ref`. */
+export function evalInElement(ctx, ref, body, varName = 'el') {
+    return evalInSim(ctx, inIframe(`${buildElAccess(ref, varName)}\n${body}`));
 }
 /** Wrap code to run inside the active page iframe (last iframe in the stack). */
 export function inIframe(code) {

package/dist/main/services/automation/handlers/app.js

@@ -1,59 +1,36 @@
 import { evalInSim, getSimulator, inIframe } from '../exec.js';
+import { parseLocationRoute } from '../../../../shared/simulator-route.js';
 export const appHandlers = {};
 // -- App domain --
+async function readRoute(ctx) {
+    const { search } = await evalInSim(ctx, `({ search: location.search })`);
+    return parseLocationRoute(search);
+}
 appHandlers['App.getCurrentPage'] = async (ctx) => {
-    const hash = await evalInSim(ctx, 'location.hash');
-    const clean = hash.replace(/^#/, '');
-    const qIdx = clean.indexOf('?');
-    const pathPart = qIdx >= 0 ? clean.substring(0, qIdx) : clean;
-    const queryPart = qIdx >= 0 ? clean.substring(qIdx + 1) : '';
-    // New format: #appid|page1|page2 — last segment is current page
-    let pagePath;
-    if (pathPart.includes('|')) {
-        const parts = pathPart.split('|');
-        pagePath = parts[parts.length - 1] ?? '';
-    }
-    else {
-        // Legacy format: #appid/pagePath
-        const slashIdx = pathPart.indexOf('/');
-        pagePath = slashIdx >= 0 ? pathPart.substring(slashIdx + 1) : pathPart;
-    }
-    const query = {};
-    if (queryPart) {
-        for (const pair of queryPart.split('&')) {
-            const [k, v] = pair.split('=');
-            if (k)
-                query[k] = decodeURIComponent(v || '');
-        }
-    }
+    const route = await readRoute(ctx);
     const iframeCount = await evalInSim(ctx, `document.querySelectorAll('iframe').length`);
-    return { pageId: iframeCount, path: pagePath, query };
+    return {
+        pageId: iframeCount,
+        path: route?.current.pagePath ?? '',
+        query: route?.current.query ?? {},
+    };
 };
 appHandlers['App.getPageStack'] = async (ctx) => {
-    const hash = await evalInSim(ctx, 'location.hash');
-    const clean = hash.replace(/^#/, '').replace(/\?.*$/, '');
+    const route = await readRoute(ctx);
     const pageStack = [];
-    if (clean.includes('|')) {
-        // New format: #appid|page1|page2 — segments after appid are pages
-        const parts = clean.split('|');
-        for (let i = 1; i < parts.length; i++) {
-            pageStack.push({ pageId: i, path: parts[i] ?? '', query: {} });
-        }
-    }
-    else {
-        // Legacy format: #appid/pagePath — single page
-        const slashIdx = clean.indexOf('/');
-        const currentPath = slashIdx >= 0 ? clean.substring(slashIdx + 1) : clean;
-        if (currentPath) {
-            pageStack.push({ pageId: 1, path: currentPath, query: {} });
-        }
+    if (!route)
+        return { pageStack };
+    // Mirrors upstream HashRouter.parseSearch: `[entry]` or `[entry, current]`.
+    pageStack.push({ pageId: 1, path: route.entry.pagePath, query: route.entry.query });
+    if (route.current.pagePath !== route.entry.pagePath) {
+        pageStack.push({ pageId: 2, path: route.current.pagePath, query: route.current.query });
     }
     return { pageStack };
 };
 appHandlers['App.callWxMethod'] = async (ctx, params) => {
     const method = params.method;
     const args = params.args || [];
-    // For navigation methods, handle specially via hash change + click
+    // For navigation methods, handle specially via DOM click / wx.* on the iframe
     if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab'].includes(method)) {
         const opts = args[0];
         const url = opts?.url;
@@ -61,20 +38,29 @@ appHandlers['App.callWxMethod'] = async (ctx, params) => {
             const cleanUrl = url.startsWith('/') ? url : `/${url}`;
             // Try clicking a matching DOM element first
             const clicked = await evalInSim(ctx, inIframe(`
-        const el = _doc.querySelector('[data-path="${cleanUrl}"]')
+        const path = ${JSON.stringify(cleanUrl)}
+        const el = Array.from(_doc.querySelectorAll('[data-path]'))
+          .find(e => e.getAttribute('data-path') === path)
         if (el) { el.click(); return true }
         return false
       `)).catch(() => false);
             if (!clicked) {
-                // Fallback: change hash
-                const hash = await evalInSim(ctx, 'location.hash');
-                const appId = hash.replace(/^#/, '').split('/')[0];
-                if (method === 'reLaunch' || method === 'redirectTo') {
-                    await evalInSim(ctx, `location.href = location.pathname + '#${appId}${cleanUrl}'`);
-                }
-                else {
-                    await evalInSim(ctx, `location.hash = '#${appId}${cleanUrl}'`);
+                // Fallback: drive navigation via wx.* on the rendered page iframe.
+                // Upstream's query router doesn't react to URL mutation; the active
+                // page's iframe exposes wx.* with the live dimina runtime bindings.
+                const apiName = JSON.stringify(method);
+                const urlJson = JSON.stringify(cleanUrl);
+                await evalInSim(ctx, `(() => {
+            const iframes = Array.from(document.querySelectorAll('iframe'))
+            for (const f of iframes) {
+              try {
+                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
+                  return
                 }
+              } catch (_) {}
+            }
+          })()`);
             }
             // Wait for navigation
             await new Promise((r) => setTimeout(r, 2000));

package/dist/main/services/automation/handlers/element.js

@@ -1,112 +1,100 @@
-import { buildElAccess, evalInSim, inIframe } from '../exec.js';
+import { evalInElement } from '../exec.js';
 import { getElementRef, registerElement } from '../registry.js';
 export const elementHandlers = {};
 // -- Element domain --
 elementHandlers['Element.tap'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.click()
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.triggerEvent'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const type = params.type;
     const detail = params.detail || {};
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.dispatchEvent(new CustomEvent('${type}', { detail: ${JSON.stringify(detail)}, bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchstart'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchstart', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchmove'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.touchend'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
-  `));
+  `);
     return {};
 };
 elementHandlers['Element.getDOMProperties'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const properties = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const properties = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el[n])
-  `));
+  `);
     return { properties };
 };
 elementHandlers['Element.getAttributes'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const attributes = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const attributes = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el.getAttribute(n))
-  `));
+  `);
     return { attributes };
 };
 elementHandlers['Element.getStyles'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;
-    const styles = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const styles = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => ''))}
     const cs = getComputedStyle(el)
     return ${JSON.stringify(names)}.map(n => cs.getPropertyValue(n))
-  `));
+  `);
     return { styles };
 };
 elementHandlers['Element.getWXML'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const type = params.type || 'inner';
     const prop = type === 'outer' ? 'outerHTML' : 'innerHTML';
-    const wxml = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    const wxml = await evalInElement(ctx, ref, `
     return el ? el.${prop} : ''
-  `));
+  `);
     return { wxml };
 };
 elementHandlers['Element.getOffset'] = async (ctx, params) => {
     const ref = getElementRef(params);
-    return evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+    return evalInElement(ctx, ref, `
     if (!el) return { left: 0, top: 0 }
     const r = el.getBoundingClientRect()
     return { left: r.left, top: r.top }
-  `));
+  `);
 };
 elementHandlers['Element.getElement'] = async (ctx, params) => {
     const parentRef = getElementRef(params);
     const selector = params.selector;
-    const escaped = selector.replace(/'/g, "\\'");
-    const info = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, 'parent')}
+    const info = await evalInElement(ctx, parentRef, `
     if (!parent) return null
-    const child = parent.querySelector('${escaped}')
+    const child = parent.querySelector(${JSON.stringify(selector)})
     if (!child) return null
     return { tagName: child.tagName.toLowerCase() }
-  `));
+  `, 'parent');
     if (!info)
         throw new Error(`Child element not found: ${selector}`);
     const combinedSelector = `${parentRef.selector} ${selector}`;
@@ -116,14 +104,12 @@ elementHandlers['Element.getElement'] = async (ctx, params) => {
 elementHandlers['Element.getElements'] = async (ctx, params) => {
     const parentRef = getElementRef(params);
     const selector = params.selector;
-    const escaped = selector.replace(/'/g, "\\'");
-    const items = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, 'parent')}
+    const items = await evalInElement(ctx, parentRef, `
     if (!parent) return []
-    return Array.from(parent.querySelectorAll('${escaped}')).map(el => ({
+    return Array.from(parent.querySelectorAll(${JSON.stringify(selector)})).map(el => ({
       tagName: el.tagName.toLowerCase(),
     }))
-  `));
+  `, 'parent');
     const combinedSelector = `${parentRef.selector} ${selector}`;
     return {
         elements: items.map((item, i) => ({

package/dist/main/services/automation/index.js

@@ -9,9 +9,9 @@
  * This server handles these messages by delegating to the workbench context
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
-import { ipcMain } from 'electron';
 import { WebSocketServer } from 'ws';
 import { AutomationChannel, SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { IpcRegistry } from '../../utils/ipc-registry.js';
 import { getSimulator } from './exec.js';
 import { toolHandlers } from './handlers/tool.js';
 import { appHandlers } from './handlers/app.js';
@@ -25,7 +25,6 @@ const handlers = {
     ...elementHandlers,
 };
 let currentPort = null;
-let portIpcRegistered = false;
 export function getAutomationPort() {
     return currentPort;
 }
@@ -40,10 +39,14 @@ export async function startAutomationServer(ctx, port = 0) {
     // ws always binds via an http.Server, so address() is AddressInfo here.
     const resolvedPort = typeof addr === 'object' && addr ? addr.port : port;
     currentPort = resolvedPort;
-    if (!portIpcRegistered) {
-        portIpcRegistered = true;
-        ipcMain.handle(AutomationChannel.GetPort, () => currentPort);
-    }
+    // Gate AutomationChannel.GetPort with the workbench sender policy (only
+    // the main renderer + workbench settings/popover overlays are allowed to
+    // read the port — see createWorkbenchSenderPolicy; the simulator webview
+    // is intentionally NOT trusted for IPC invokes).
+    const portIpc = new IpcRegistry(ctx.senderPolicy);
+    portIpc.handle(AutomationChannel.GetPort, () => {
+        return currentPort;
+    });
     function broadcast(event) {
         const msg = JSON.stringify(event);
         for (const ws of clients) {
@@ -51,19 +54,55 @@ export async function startAutomationServer(ctx, port = 0) {
                 ws.send(msg);
         }
     }
-    // Forward simulator console logs as App.logAdded events
+    // Forward simulator console logs as App.logAdded events.
+    // Track the polling interval + stop timer + currently-attached sim and
+    // the named handler so we can fully detach on close() or sim destruction.
+    // Without this the listener accumulates across create/dispose cycles and
+    // across simulator rebuilds.
     let consoleForwardingSetup = false;
+    let pollInterval = null;
+    let pollStopTimer = null;
+    let attachedSim = null;
+    let ipcMessageHostHandler = null;
+    let simDestroyedHandler = null;
+    function detachConsoleForwarding() {
+        if (attachedSim) {
+            if (ipcMessageHostHandler) {
+                try {
+                    if (!attachedSim.isDestroyed()) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ;
+                        attachedSim.removeListener('ipc-message-host', ipcMessageHostHandler);
+                    }
+                }
+                catch { /* noop */ }
+            }
+            if (simDestroyedHandler) {
+                try {
+                    if (!attachedSim.isDestroyed()) {
+                        attachedSim.removeListener('destroyed', simDestroyedHandler);
+                    }
+                }
+                catch { /* noop */ }
+            }
+        }
+        attachedSim = null;
+        ipcMessageHostHandler = null;
+        simDestroyedHandler = null;
+    }
     function setupConsoleForwarding() {
         if (consoleForwardingSetup)
             return;
         consoleForwardingSetup = true;
-        // Poll for simulator and set up listener
-        const check = setInterval(() => {
+        pollInterval = setInterval(() => {
             const sim = getSimulator(ctx);
             if (!sim)
                 return;
-            clearInterval(check);
-            sim.on('ipc-message-host', (_event, channel, data) => {
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+            const onIpcMessageHost = (_event, channel, data) => {
                 if (channel === SimulatorChannel.Console) {
                     const logData = data;
                     broadcast({
@@ -71,10 +110,29 @@ export async function startAutomationServer(ctx, port = 0) {
                         params: { type: logData.level || 'log', args: logData.args || [] },
                     });
                 }
-            });
+            };
+            const onSimDestroyed = () => {
+                // Sim webContents is dead — drop refs (removeListener on a destroyed
+                // sender would throw) and allow re-attach to a new simulator.
+                attachedSim = null;
+                ipcMessageHostHandler = null;
+                simDestroyedHandler = null;
+                consoleForwardingSetup = false;
+            };
+            attachedSim = sim;
+            ipcMessageHostHandler = onIpcMessageHost;
+            simDestroyedHandler = onSimDestroyed;
+            sim.on('ipc-message-host', onIpcMessageHost);
+            sim.once('destroyed', onSimDestroyed);
         }, 1000);
         // Stop polling after 30s
-        setTimeout(() => clearInterval(check), 30000);
+        pollStopTimer = setTimeout(() => {
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+            pollStopTimer = null;
+        }, 30000);
     }
     wss.on('connection', (ws) => {
         clients.add(ws);
@@ -109,8 +167,25 @@ export async function startAutomationServer(ctx, port = 0) {
     });
     return {
         close: () => {
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+            if (pollStopTimer) {
+                clearTimeout(pollStopTimer);
+                pollStopTimer = null;
+            }
+            detachConsoleForwarding();
+            for (const ws of clients) {
+                try {
+                    ws.close();
+                }
+                catch { /* noop */ }
+            }
+            clients.clear();
             if (currentPort === resolvedPort)
                 currentPort = null;
+            void portIpc.dispose();
             wss.close();
         },
         port: resolvedPort,

package/dist/main/services/default-adapter.js

@@ -4,12 +4,12 @@ import { simulatorDir } from '../utils/paths.js';
 export const defaultAdapter = {
     async openProject(opts) {
         const diminaKit = await import('@dimina-kit/devkit');
-        const openProject = diminaKit.openProject;
-        return openProject({
+        const openProjectOpts = {
             outputDir: path.join(app.getPath('userData'), 'dimina-fe-output'),
             ...opts,
             simulatorDir,
-        });
+        };
+        return diminaKit.openProject(openProjectOpts);
     },
 };
 //# sourceMappingURL=default-adapter.js.map

package/dist/main/services/mcp/index.d.ts

@@ -12,4 +12,5 @@
  *   - `./target-manager.ts`   dual-target CDP connection + reconnect
  */
 export { startMcpServer } from './server.js';
+export { getMcpStatus, type McpRuntimeStatus } from './status.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/mcp/index.js

@@ -12,4 +12,5 @@
  *   - `./target-manager.ts`   dual-target CDP connection + reconnect
  */
 export { startMcpServer } from './server.js';
+export { getMcpStatus } from './status.js';
 //# sourceMappingURL=index.js.map

package/dist/main/services/mcp/server.d.ts

@@ -6,5 +6,6 @@
  * Tool registration lives in `./tool-registry` and `./tools/*`; this file
  * only wires up transports and lifecycle.
  */
-export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number): void;
+import { type Disposable } from '../../utils/disposable.js';
+export declare function startMcpServer(resolvedCdpPort: number, mcpPort: number): Disposable;
 //# sourceMappingURL=server.d.ts.map

package/dist/main/services/mcp/server.js

@@ -10,7 +10,9 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { createServer } from 'http';
 import { createRequire } from 'node:module';
+import { toDisposable } from '../../utils/disposable.js';
 import { connectTarget, setCdpPort } from './target-manager.js';
+import { recordMcpFailed, recordMcpStarted, recordMcpStopped } from './status.js';
 import { registerCommonTargetTools } from './tool-registry.js';
 import { registerContextTools } from './tools/context-tools.js';
 import { registerSimulatorTools } from './tools/simulator-tools.js';
@@ -64,13 +66,21 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
     httpServer.on('error', (err) => {
         if (err.code === 'EADDRINUSE') {
             console.warn(`[MCP] Port ${mcpPort} already in use — MCP server not started`);
+            recordMcpFailed('port-in-use');
         }
         else {
             console.error('[MCP] Server error:', err);
+            recordMcpFailed(err.message);
         }
     });
     httpServer.listen(mcpPort, '127.0.0.1', () => {
         console.log(`[MCP] SSE server listening on http://127.0.0.1:${mcpPort}/sse`);
+        recordMcpStarted(mcpPort);
+    });
+    return toDisposable(() => {
+        transports.clear();
+        httpServer.close();
+        recordMcpStopped();
     });
 }
 //# sourceMappingURL=server.js.map

package/dist/main/services/mcp/status.d.ts

@@ -0,0 +1,10 @@
+export interface McpRuntimeStatus {
+    running: boolean;
+    port: number | null;
+    error: string | null;
+}
+export declare function getMcpStatus(): McpRuntimeStatus;
+export declare function recordMcpStarted(port: number): void;
+export declare function recordMcpFailed(error: string): void;
+export declare function recordMcpStopped(): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/main/services/mcp/status.js

@@ -0,0 +1,14 @@
+let status = { running: false, port: null, error: null };
+export function getMcpStatus() {
+    return { ...status };
+}
+export function recordMcpStarted(port) {
+    status = { running: true, port, error: null };
+}
+export function recordMcpFailed(error) {
+    status = { running: false, port: null, error };
+}
+export function recordMcpStopped() {
+    status = { running: false, port: null, error: null };
+}
+//# sourceMappingURL=status.js.map

package/dist/main/services/mcp/target-manager.js

@@ -10,10 +10,11 @@
  *   - rolling buffers of console log and network request events
  */
 import CDP from 'chrome-remote-interface';
+import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
 const SIMULATOR_URL_PATTERN = 'localhost:7788';
 const MAX_BUFFER = 500;
 const RECONNECT_INTERVAL_MS = 3000;
-let cdpPort = 9222;
+let cdpPort = DEFAULT_CDP_PORT;
 const targets = {
     simulator: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
     workbench: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },

package/dist/main/services/module.d.ts

@@ -0,0 +1,18 @@
+import type { Disposable } from '../utils/disposable.js';
+import type { WorkbenchContext } from './workbench-context.js';
+/**
+ * A composable unit of workbench functionality.
+ *
+ * Built-in modules (projects, session, simulator, popover, settings) are
+ * implemented as `WorkbenchModule` values; hosts may also inject extra
+ * modules via `WorkbenchAppConfig.extraModules`.
+ *
+ * `setup` is invoked once during workbench bootstrap. The returned
+ * Disposable is added to `ctx.registry` so module teardown is symmetric
+ * with the rest of the workbench lifecycle.
+ */
+export interface WorkbenchModule {
+    /** Set up the module against ctx. Returns a Disposable owned by ctx.registry. */
+    setup(ctx: WorkbenchContext): Disposable;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/main/services/module.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module.js.map

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

@@ -8,6 +8,8 @@ import type { ProjectSettings } from '../projects/project-repository.js';
 export interface ProjectStatusPayload {
     status: string;
     message: string;
+    /** True when the status update is emitted by the file-watcher rebuild loop. */
+    hotReload?: boolean;
 }
 /**
  * Payload for the `settings:init` event sent into the embedded settings overlay
@@ -50,8 +52,6 @@ export interface RendererNotifier {
     popoverClosed(): void;
     /** Ask the main renderer to relaunch the simulator with a new config. */
     popoverRelaunch(config: CompileConfig): void;
-    /** Ask the main renderer to re-initialise the devtools panels. */
-    workbenchReset(): void;
     /** Tell the main renderer the toolbar actions list has changed. */
     toolbarActionsChanged(): void;
     /** Initialise the currently shown compile popover overlay. */
@@ -67,7 +67,9 @@ export interface RendererNotifier {
  * between the notifier module and workbench-context.
  */
 export interface NotifierContext {
-    mainWindow: BrowserWindow;
+    windows: {
+        readonly mainWindow: BrowserWindow;
+    };
     views: {
         getSettingsWebContents(): WebContents | null;
     };

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

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchChannel, ToolbarChannel, WorkbenchSettingsChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, ToolbarChannel, WorkbenchSettingsChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -13,9 +13,9 @@ function liveWebContents(wc) {
  */
 export function createRendererNotifier(ctx) {
     function sendToMain(channel, ...args) {
-        if (ctx.mainWindow.isDestroyed())
+        if (ctx.windows.mainWindow.isDestroyed())
             return;
-        const wc = liveWebContents(ctx.mainWindow.webContents);
+        const wc = liveWebContents(ctx.windows.mainWindow.webContents);
         if (!wc)
             return;
         wc.send(channel, ...args);
@@ -39,9 +39,6 @@ export function createRendererNotifier(ctx) {
         popoverRelaunch(config) {
             sendToMain(PopoverChannel.Relaunch, config);
         },
-        workbenchReset() {
-            sendToMain(WorkbenchChannel.Reset);
-        },
         toolbarActionsChanged() {
             sendToMain(ToolbarChannel.ActionsChanged);
         },

package/dist/main/services/projects/builtin-templates.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectTemplate } from './types.js';
+export declare const BUILTIN_TEMPLATES: ProjectTemplate[];
+//# sourceMappingURL=builtin-templates.d.ts.map