@dimina-kit/devtools 0.4.0 → 0.5.0

package/dist/main/runtime/miniapp-runtime.d.ts

@@ -1,6 +1,6 @@
 /**
- * MiniappRuntime — the stable, host-facing contract surface (foundation.md §3
- * "MiniappRuntime 契约" layer).
+ * MiniappRuntime — the stable, host-facing contract surface documented in
+ * host-migration.md's public-contract section.
  *
  * HAND-WRITTEN, not derived from `WorkbenchContext`. A `Pick`-style projection
  * would drag every nested internal service type (ViewManager,
@@ -18,7 +18,8 @@
  *  - `workspace.openProject` stays writable (no `readonly`) for backward
  *    compat: hosts MAY still gate permissions by reassigning it. The preferred
  *    path is now the declarative `WorkbenchAppConfig.onBeforeOpenProject` hook
- *    (runs before any side effect, throw to veto) — see host-migration.md §7.
+ *    (runs before any side effect, throw to veto) — see host-migration.md's
+ *    `onBeforeOpenProject` hook section.
  *
  * `asMiniappRuntime(ctx)` is an identity return — the contract is a typed
  * VIEW onto the live context, not a snapshot/projection. That is what makes
@@ -72,6 +73,25 @@ export interface DiminaHostToolbarPageBridge {
     send: (channel: string, payload: unknown) => void;
     onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
 }
+/**
+ * The page-side bridge injected into the host-sidebar WCV as
+ * `window.diminaHostSidebar` (see src/preload/runtime/host-sidebar-port.ts).
+ * Shape identical to `DiminaHostToolbarPageBridge` — the port-channel
+ * envelope and queueing/guard behaviour don't vary by slot.
+ */
+export interface DiminaHostSidebarPageBridge {
+    send: (channel: string, payload: unknown) => void;
+    onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
+}
+/**
+ * The page-side bridge injected into the host-dialog WCV as
+ * `window.diminaHostDialog` (see src/preload/runtime/host-dialog-port.ts).
+ * Shape identical to `DiminaHostToolbarPageBridge`.
+ */
+export interface DiminaHostDialogPageBridge {
+    send: (channel: string, payload: unknown) => void;
+    onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
+}
 declare global {
     interface Window {
         /**
@@ -80,51 +100,68 @@ declare global {
          * else, so page code must runtime-guard before use.
          */
         diminaHostToolbar?: DiminaHostToolbarPageBridge;
+        /**
+         * Present ONLY inside the host-sidebar WebContentsView's main frame
+         * (guarded injection — see host-sidebar-runtime.ts); optional everywhere
+         * else, so page code must runtime-guard before use.
+         */
+        diminaHostSidebar?: DiminaHostSidebarPageBridge;
+        /**
+         * Present ONLY inside the host-dialog WebContentsView's main frame
+         * (guarded injection — see host-dialog-runtime.ts); optional everywhere
+         * else, so page code must runtime-guard before use.
+         */
+        diminaHostDialog?: DiminaHostDialogPageBridge;
     }
 }
 /**
- * Host-facing control surface for the toolbar WebContentsView — a
- * message-channel surface (`send`/`onMessage`), with no `webContents` escape
- * hatch (that would put Electron types on the contract).
+ * Shared message-channel surface for every downstream-controllable host slot
+ * (toolbar/sidebar/dialog) — `send`/`onMessage`/`onReady` plus preload and
+ * content loading, with no `webContents` escape hatch (that would put
+ * Electron types on the contract). Each slot extends this with its own
+ * extent/visibility members.
  */
-export interface MiniappHostToolbar {
+export interface MiniappHostSlotChannel {
     /**
-     * The host's own `webPreferences.preload` for the toolbar view (purely
-     * additive — never replaces the framework's session-resident height
+     * The host's own `webPreferences.preload` for this slot's view (purely
+     * additive — never replaces the framework's session-resident size
      * advertiser). Must be set before the view is (re)created; `null` (default)
      * means "no host preload".
      */
     setPreloadPath: (path: string | null) => void;
-    /** Load a local file into the toolbar view (lazy-creates the view). */
+    /** Load a local file into the slot's view (lazy-creates the view). */
     loadFile: (path: string) => Promise<void>;
-    /** Load a URL into the toolbar view (lazy-creates the view). */
+    /** Load a URL into the slot's view (lazy-creates the view). */
     loadURL: (url: string) => Promise<void>;
     /**
-     * Post `{ channel, payload }` to the toolbar page. Gated and non-queueing:
+     * Post `{ channel, payload }` to the slot's page. Gated and non-queueing:
      * returns false (delivering nothing, creating no view) while there is no
-     * live toolbar webContents or the current load's MessagePort handshake
-     * hasn't completed; true once the envelope went out.
+     * live webContents or the current load's MessagePort handshake hasn't
+     * completed; true once the envelope went out.
      */
     send: (channel: string, payload: unknown) => boolean;
     /**
-     * Register a host-side handler for messages the toolbar page sends via
-     * `window.diminaHostToolbar.send(channel, payload)`. May be called before
-     * the view exists; survives page reloads. `dispose()` detaches (idempotent).
+     * Register a host-side handler for messages the slot's page sends via
+     * `window.dimina*.send(channel, payload)`. May be called before the view
+     * exists; survives page reloads. `dispose()` detaches (idempotent).
      */
     onMessage: (channel: string, handler: (payload: unknown) => void) => {
         dispose: () => void;
     };
     /**
      * Observe handshake readiness. Fires the handler once per load generation,
-     * exactly when the toolbar page's MessagePort handshake completes (i.e.
-     * when `send` flips to true). Registering while the channel is already
-     * ready fires once asynchronously on a microtask (missed-signal guard);
-     * a reload / re-handshake fires registered handlers again. `dispose()`
+     * exactly when the slot page's MessagePort handshake completes (i.e. when
+     * `send` flips to true). Registering while the channel is already ready
+     * fires once asynchronously on a microtask (missed-signal guard); a
+     * reload / re-handshake fires registered handlers again. `dispose()`
      * detaches (idempotent).
      */
     onReady: (handler: () => void) => {
         dispose: () => void;
     };
+}
+/** Host-facing control surface for the toolbar WebContentsView. */
+export interface MiniappHostToolbar extends MiniappHostSlotChannel {
     /**
      * Pin (`{ fixed }`) or unpin (`'auto'`) the toolbar strip height. `'auto'`
      * (default) lets the in-page height advertiser drive the placeholder.
@@ -135,6 +172,36 @@ export interface MiniappHostToolbar {
         fixed: number;
     }) => void;
 }
+/** Host-facing control surface for the sidebar WebContentsView. */
+export interface MiniappHostSidebar extends MiniappHostSlotChannel {
+    /**
+     * Pin (`{ fixed }`) or unpin (`'auto'`) the sidebar strip width. `'auto'`
+     * (default) lets the in-page width advertiser drive the placeholder.
+     * `{ fixed }` values must be finite and non-negative — anything else throws
+     * a `TypeError` synchronously and leaves the standing mode untouched.
+     */
+    setWidthMode: (mode: 'auto' | {
+        fixed: number;
+    }) => void;
+}
+/**
+ * Host-facing control surface for the by-demand, dual-axis-autosized dialog
+ * WebContentsView. Unlike the persistent toolbar/sidebar strips, the dialog
+ * is shown/hidden explicitly — there is no extent-mode setter (both axes
+ * always self-size from the page's own measured content).
+ */
+export interface MiniappHostDialog extends MiniappHostSlotChannel {
+    /**
+     * Show the dialog, centered in the main window using its self-advertised
+     * size on both axes. Creates the view's placement if needed; does not
+     * (re)load content — the host must `loadURL`/`loadFile` first.
+     */
+    show: () => void;
+    /** Hide the dialog (kept alive, content preserved) without destroying the view. */
+    hide: () => void;
+    /** Whether the dialog is currently shown. */
+    isVisible: () => boolean;
+}
 /**
  * The audited workspace surface: project list membership, session lifecycle,
  * and minimal session state. Thumbnails / per-project settings / providers
@@ -176,9 +243,11 @@ export interface MiniappWorkspace {
  * plumbing is a deliberate semver decision, not an accident of projection.
  */
 export interface MiniappRuntime {
-    /** View layer — only the host-owned toolbar control is public. */
+    /** View layer — only the host-owned slot controls are public. */
     views: {
         readonly hostToolbar: MiniappHostToolbar;
+        readonly hostSidebar: MiniappHostSidebar;
+        readonly hostDialog: MiniappHostDialog;
     };
     /** Project + session workspace (see {@link MiniappWorkspace}). */
     workspace: MiniappWorkspace;

package/dist/main/services/app-services.d.ts

@@ -0,0 +1,62 @@
+import type { BrowserWindow } from 'electron';
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import { type SimulatorApiRegistry } from './simulator/custom-apis.js';
+/**
+ * The services that belong to the whole application rather than to one window.
+ *
+ * They are all registered or configured ONCE by the host (through
+ * `WorkbenchAppConfig` and the `WorkbenchAppInstance` registration methods),
+ * so every window context reads the same instance. Anything whose owner is a
+ * single window — views, connections, the CDP broker, the workspace — stays on
+ * `WorkbenchContext` instead.
+ */
+export interface AppServices {
+    /** Backing store for the project list. One list, shown by every window. */
+    projectsProvider: ProjectsProvider;
+    /** Built-in templates merged with the host's, per `builtinTemplates`. */
+    projectTemplates: ProjectTemplate[];
+    /**
+     * Reference-counted `webContents.id` → live registration count for
+     * host-owned BrowserWindows registered as trusted senders. A host window is
+     * registered against the app, not against whichever window happened to be
+     * open at the time, so the map is shared and every context's sender policy
+     * consults the same entries.
+     */
+    trustedWindowSenderIds: Map<number, number>;
+    /**
+     * Simulator custom APIs registered by the host. The host registers each
+     * handler once (in `onSetup`), so the registry is app-wide: a window opened
+     * later must answer the same `wx.*` calls as the one that was open during
+     * registration.
+     */
+    simulatorApis: SimulatorApiRegistry;
+}
+export interface CreateAppServicesOptions {
+    projectsProvider?: ProjectsProvider;
+    projectTemplates?: ProjectTemplate[];
+    builtinTemplates?: 'all' | 'none' | readonly string[];
+}
+export declare function createAppServices(opts?: CreateAppServicesOptions): AppServices;
+/**
+ * Adds `win.webContents` to the trusted-sender set and returns a Disposable
+ * that removes it again.
+ *
+ * Trust is reference-counted: registering the SAME window N times keeps it
+ * trusted until every one of the N returned Disposables has been disposed.
+ * Each register bumps the count, each dispose decrements it, and the window is
+ * un-trusted only when the count reaches zero.
+ *
+ * The window's `closed` event short-circuits the ref-count: it deletes the
+ * map entry outright (the window is dead, so it must be un-trusted
+ * immediately regardless of how many Disposables are still outstanding).
+ * After `closed`, disposing any leftover Disposable is a safe no-op — the
+ * map entry is already gone, so the decrement finds `undefined` and bails
+ * without driving the count negative or resurrecting trust.
+ *
+ * Each returned Disposable is itself idempotent (`removed` flag), and its
+ * `closed` listener removes itself once fired so a long-lived app doesn't
+ * accumulate dead listeners on closed windows.
+ */
+export declare function registerTrustedWindow(services: Pick<AppServices, 'trustedWindowSenderIds'>, win: BrowserWindow): Disposable;
+//# sourceMappingURL=app-services.d.ts.map

package/dist/main/services/app-services.js

@@ -0,0 +1,64 @@
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+import { createLocalProjectsProvider } from './projects/local-provider.js';
+import { resolveTemplates } from './projects/templates.js';
+import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
+import { createSimulatorApiRegistry, } from './simulator/custom-apis.js';
+export function createAppServices(opts = {}) {
+    return {
+        projectsProvider: opts.projectsProvider ?? createLocalProjectsProvider(),
+        projectTemplates: resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all'),
+        trustedWindowSenderIds: new Map(),
+        simulatorApis: createSimulatorApiRegistry(),
+    };
+}
+/**
+ * Adds `win.webContents` to the trusted-sender set and returns a Disposable
+ * that removes it again.
+ *
+ * Trust is reference-counted: registering the SAME window N times keeps it
+ * trusted until every one of the N returned Disposables has been disposed.
+ * Each register bumps the count, each dispose decrements it, and the window is
+ * un-trusted only when the count reaches zero.
+ *
+ * The window's `closed` event short-circuits the ref-count: it deletes the
+ * map entry outright (the window is dead, so it must be un-trusted
+ * immediately regardless of how many Disposables are still outstanding).
+ * After `closed`, disposing any leftover Disposable is a safe no-op — the
+ * map entry is already gone, so the decrement finds `undefined` and bails
+ * without driving the count negative or resurrecting trust.
+ *
+ * Each returned Disposable is itself idempotent (`removed` flag), and its
+ * `closed` listener removes itself once fired so a long-lived app doesn't
+ * accumulate dead listeners on closed windows.
+ */
+export function registerTrustedWindow(services, win) {
+    const senderId = win.webContents.id;
+    const counts = services.trustedWindowSenderIds;
+    counts.set(senderId, (counts.get(senderId) ?? 0) + 1);
+    let removed = false;
+    const onClosed = () => {
+        // The window is gone: zero the ref-count for this sender id outright,
+        // regardless of any other outstanding registrations for the same window.
+        counts.delete(senderId);
+        win.removeListener('closed', onClosed);
+    };
+    function remove() {
+        if (removed)
+            return;
+        removed = true;
+        win.removeListener('closed', onClosed);
+        const count = counts.get(senderId);
+        // `undefined` → the entry was already cleared (e.g. by `closed` or by a
+        // prior sibling's decrement that hit zero). Nothing to do — never go
+        // negative, never resurrect trust.
+        if (count === undefined)
+            return;
+        if (count <= 1)
+            counts.delete(senderId);
+        else
+            counts.set(senderId, count - 1);
+    }
+    win.once('closed', onClosed);
+    return toDisposable(remove);
+}
+//# sourceMappingURL=app-services.js.map

package/dist/main/services/automation/connection-target.d.ts

@@ -0,0 +1,36 @@
+import type { WindowService } from '../window-service.js';
+import type { WorkspaceService } from '../workspace/workspace-service.js';
+/** The slice of a window context that decides where a connection's commands go. */
+export interface TargetContext {
+    windows: Pick<WindowService, 'mainWindow'>;
+    workspace: Pick<WorkspaceService, 'hasActiveSession'>;
+}
+/**
+ * The project window one automation connection acts on.
+ *
+ * The active context follows window focus, so resolving it afresh per message
+ * would let a click on another project's window redirect a script that is
+ * already driving one — the script does nothing wrong and its commands land
+ * somewhere else. A connection therefore PINS the first context it reaches
+ * that has a session and keeps it for the rest of its life. Which window a
+ * connection drives is decided by what it reached first, never by what the
+ * user is looking at.
+ *
+ * Nothing is pinned before a project window exists: a client may connect at
+ * boot and open a project afterwards, so until a context with a session shows
+ * up every use resolves the active one (the project list, which drives
+ * nothing). Pinning the list window would tie the connection to a window that
+ * can never run a command.
+ */
+export interface ConnectionTarget<T extends TargetContext> {
+    /**
+     * The context to run a command against. Throws once the pinned window is
+     * gone, so a connection whose project was closed fails loudly instead of
+     * sliding onto whichever project happens to be open now.
+     */
+    resolve(): T;
+    /** The same target, but null instead of a throw once its window is gone. */
+    peek(): T | null;
+}
+export declare function createConnectionTarget<T extends TargetContext>(getCtx: () => T): ConnectionTarget<T>;
+//# sourceMappingURL=connection-target.d.ts.map

package/dist/main/services/automation/connection-target.js

@@ -0,0 +1,29 @@
+export function createConnectionTarget(getCtx) {
+    let pinned = null;
+    // The window, not the session, is what a connection is pinned to: closing
+    // the project inside a window (`Tool.close`) leaves that window able to open
+    // another, while destroying the window ends the connection's target for good.
+    const isGone = (ctx) => {
+        const win = ctx.windows.mainWindow;
+        return !win || win.isDestroyed();
+    };
+    const current = () => {
+        if (pinned)
+            return isGone(pinned) ? null : pinned;
+        const ctx = getCtx();
+        if (ctx.workspace.hasActiveSession())
+            pinned = ctx;
+        return ctx;
+    };
+    return {
+        peek: current,
+        resolve() {
+            const ctx = current();
+            if (!ctx) {
+                throw new Error('The project window this connection was driving has been closed. Reconnect to drive another project.');
+            }
+            return ctx;
+        },
+    };
+}
+//# sourceMappingURL=connection-target.js.map

package/dist/main/services/automation/console-bridge.d.ts

@@ -0,0 +1,28 @@
+import type { WebContents } from 'electron';
+import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
+import type { ConsoleForwarder } from '../console-forward/index.js';
+import type { RpcEvent } from './shared.js';
+/** The slice of a window context the two console taps read. */
+export interface ConsoleTargetContext {
+    consoleForwarder?: ConsoleForwarder;
+    connections: ConnectionRegistry;
+}
+/**
+ * The `App.logAdded` stream of ONE automation connection, taken from the same
+ * window that connection's commands reach.
+ *
+ * Two taps, because the two architectures deliver guest console differently:
+ *   - native-host: the render/service preloads post to main, bridge-router
+ *     routes into the window's always-on ConsoleForwarder, and we subscribe.
+ *   - default dimina-fe: the page/service console flows through the simulator
+ *     guest's `ipc-message-host` channel, so we listen on that webContents.
+ * Both are re-pointed by `sync()`, which is what keeps the log stream and the
+ * command stream on the same window as the target and its simulator change.
+ */
+export interface ConsoleBridge {
+    /** Re-point both taps at the connection's current target. */
+    sync(): void;
+    dispose(): void;
+}
+export declare function createConsoleBridge<T extends ConsoleTargetContext>(target: () => T | null, simulatorOf: (ctx: T) => WebContents | null, emit: (event: RpcEvent) => void): ConsoleBridge;
+//# sourceMappingURL=console-bridge.d.ts.map

package/dist/main/services/automation/console-bridge.js

@@ -0,0 +1,91 @@
+import { SimulatorChannel } from '../../../shared/ipc-channels.js';
+/**
+ * How often an idle connection re-checks its target for a console to attach
+ * to. A connection that never sends a message (a script that only listens for
+ * logs) has no other moment to notice its window's simulator appearing or
+ * being replaced by a rebuild.
+ */
+const SYNC_INTERVAL_MS = 1000;
+export function createConsoleBridge(target, simulatorOf, emit) {
+    let subscribedForwarder = null;
+    let forwarderSub;
+    let attachedSim = null;
+    let simHandler = null;
+    // The destroyed-teardown is owned by the sim's connection rather than a
+    // bespoke `sim.once('destroyed')`, so it cannot accumulate across re-attaches.
+    let simDestroyedDisposer = null;
+    function logAdded(entry) {
+        const e = entry ?? {};
+        emit({ method: 'App.logAdded', params: { type: e.level || 'log', args: e.args || [] } });
+    }
+    // Keyed on the forwarder itself, not the context: a window is wired with its
+    // forwarder after the context exists, so a context-identity check would miss
+    // the forwarder arriving on a context we already looked at.
+    function syncForwarder(ctx) {
+        const forwarder = ctx?.consoleForwarder ?? null;
+        if (forwarder === subscribedForwarder)
+            return;
+        forwarderSub?.dispose();
+        subscribedForwarder = forwarder;
+        forwarderSub = forwarder?.subscribe((entry) => logAdded(entry));
+    }
+    function detachSim() {
+        if (attachedSim && simHandler) {
+            try {
+                if (!attachedSim.isDestroyed()) {
+                    ;
+                    attachedSim.removeListener('ipc-message-host', simHandler);
+                }
+            }
+            catch { /* noop */ }
+        }
+        try {
+            simDestroyedDisposer?.dispose();
+        }
+        catch { /* noop */ }
+        attachedSim = null;
+        simHandler = null;
+        simDestroyedDisposer = null;
+    }
+    function syncSim(ctx) {
+        const sim = ctx ? simulatorOf(ctx) : null;
+        const next = sim && !sim.isDestroyed() ? sim : null;
+        if (next === attachedSim)
+            return;
+        detachSim();
+        if (!next || !ctx)
+            return;
+        const onIpcMessageHost = (_event, channel, data) => {
+            if (channel !== SimulatorChannel.Console)
+                return;
+            logAdded(data);
+        };
+        attachedSim = next;
+        simHandler = onIpcMessageHost;
+        next.on('ipc-message-host', onIpcMessageHost);
+        simDestroyedDisposer = ctx.connections.acquire(next).own(() => {
+            // Dead webContents: drop the refs (removeListener on it would throw) and
+            // let the next sync attach to the replacement.
+            attachedSim = null;
+            simHandler = null;
+            simDestroyedDisposer = null;
+        });
+    }
+    function sync() {
+        const ctx = target();
+        syncForwarder(ctx);
+        syncSim(ctx);
+    }
+    const timer = setInterval(sync, SYNC_INTERVAL_MS);
+    return {
+        sync,
+        dispose() {
+            clearInterval(timer);
+            detachSim();
+            forwarderSub?.dispose();
+            forwarderSub = undefined;
+            subscribedForwarder = null;
+        },
+    };
+}
+//# sourceMappingURL=console-bridge.js.map

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

@@ -11,10 +11,10 @@ async function readRoute(ctx) {
 }
 /**
  * Native-host: derive the visible page's `{ pagePath, query }` from the active
- * render guest. The page-stack depth isn't surfaced by the bridge handle, so the
- * native page stack is reported as the single active page (see App.getPageStack).
- * Reads the guest's own `location.search` — the render-host preload encodes
- * `pagePath` (+ per-page query) there.
+ * render guest. This is the source for `App.getCurrentPage` and the fallback for
+ * `App.getPageStack` before DeviceShell reports its full ordered stack through
+ * the bridge. The render-host preload encodes `pagePath` (+ per-page query) in
+ * the guest's own `location.search`.
  */
 async function readNativeActivePage(ctx) {
     const renderWc = getActivePageWc(ctx);

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

@@ -20,27 +20,61 @@ elementHandlers['Element.triggerEvent'] = async (ctx, params) => {
   `);
     return {};
 };
-elementHandlers['Element.touchstart'] = async (ctx, params) => {
-    const ref = getElementRef(params);
-    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 evalInElement(ctx, ref, `
-    if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
-  `);
-    return {};
-};
-elementHandlers['Element.touchend'] = async (ctx, params) => {
-    const ref = getElementRef(params);
-    await evalInElement(ctx, ref, `
-    if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
-  `);
-    return {};
-};
+/**
+ * Touch events must carry real touch points: the gesture layer reads coordinates
+ * off `touches` / `changedTouches` to decide tap vs. move-cancel, so an event with
+ * empty lists reaches it as a touch that happened nowhere. The protocol lets the
+ * caller omit points entirely (`touchstart()` with no args), in which case the
+ * element's centre — read from live layout, not a fixed offset — stands in for
+ * where a finger would land.
+ */
+function touchHandler(type) {
+    // A finished touch is no longer among the active `touches`, only in `changedTouches`.
+    const fallbackTouches = type === 'touchend' ? '[]' : '[{}]';
+    return async (ctx, params) => {
+        const ref = getElementRef(params);
+        const touches = params.touches ?? null;
+        // The protocol spells it `changeTouches`; the DOM event field is `changedTouches`.
+        const changed = params.changeTouches ?? null;
+        await evalInElement(ctx, ref, `
+      if (!el) throw new Error('Element not found')
+      const rect = el.getBoundingClientRect()
+      const centreX = rect.left + rect.width / 2
+      const centreY = rect.top + rect.height / 2
+      const make = (p, i) => {
+        const clientX = p.clientX != null ? p.clientX : (p.pageX != null ? p.pageX - scrollX : centreX)
+        const clientY = p.clientY != null ? p.clientY : (p.pageY != null ? p.pageY - scrollY : centreY)
+        return new Touch({
+          identifier: p.identifier != null ? p.identifier : i,
+          target: el,
+          clientX,
+          clientY,
+          pageX: p.pageX != null ? p.pageX : clientX + scrollX,
+          pageY: p.pageY != null ? p.pageY : clientY + scrollY,
+          screenX: clientX,
+          screenY: clientY,
+          force: 1,
+        })
+      }
+      const raw = ${JSON.stringify(touches)}
+      const rawChanged = ${JSON.stringify(changed)}
+      const active = (raw || ${fallbackTouches}).map(make)
+      const changedList = (rawChanged || raw || [{}]).map(make)
+      el.dispatchEvent(new TouchEvent('${type}', {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        touches: active,
+        targetTouches: active,
+        changedTouches: changedList,
+      }))
+    `);
+        return {};
+    };
+}
+elementHandlers['Element.touchstart'] = touchHandler('touchstart');
+elementHandlers['Element.touchmove'] = touchHandler('touchmove');
+elementHandlers['Element.touchend'] = touchHandler('touchend');
 elementHandlers['Element.getDOMProperties'] = async (ctx, params) => {
     const ref = getElementRef(params);
     const names = params.names;

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

@@ -9,11 +9,22 @@
  * This server handles these messages by delegating to the workbench context
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
+import { type IpcInput } from '../../utils/ipc-context-source.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 export interface AutomationServer {
     close: () => void;
     port: number;
 }
 export declare function getAutomationPort(): number | null;
-export declare function startAutomationServer(ctx: WorkbenchContext, port?: number): Promise<AutomationServer>;
+/**
+ * `getCtx` rather than a context: the server binds its port at boot, before any
+ * project window exists, so there is nothing to capture yet. Each connection
+ * then pins the first project window it reaches and keeps driving that one —
+ * `getCtx` is how it finds that window, not a per-message lookup.
+ *
+ * `senders` covers every live window instead, because the port channel is asked
+ * by renderers `getCtx` never names: the project list and background project
+ * windows all start automation clients of their own.
+ */
+export declare function startAutomationServer(getCtx: () => WorkbenchContext, senders: IpcInput<WorkbenchContext>, port?: number): Promise<AutomationServer>;
 //# sourceMappingURL=index.d.ts.map