@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/windows/internal-devtools-window/index.js

@@ -0,0 +1,160 @@
+import { BrowserWindow, View, WebContentsView } from 'electron';
+export function createInternalDevtoolsWindow(target, opts) {
+    let win = null;
+    // The host WebContentsView, kept so open()/close paths can push the host
+    // transition themselves (see notifyHostChanged's dedup comment).
+    let hostView = null;
+    const hostChangedHandlers = new Set();
+    // The host wc subscribers currently see (non-null only while the window is
+    // visible) — the single value the late-subscriber catch-up replays.
+    let currentHost = null;
+    // A throwing handler must never stop the fan-out — console-forward's own
+    // `sink(entry)` broadcast (console-forward/index.ts) uses the same
+    // isolation for exactly this reason.
+    //
+    // Dedups on the TRANSITION, not the event count: this controller pushes
+    // the transition explicitly at every point it performs one (open(), the
+    // intercepted close, dispose/'closed'), AND the native 'show'/'hide'
+    // handlers below may report the same transition again. The explicit push
+    // is the authority — on real macOS the native events were observed
+    // (instrumented-bundle trace against the live app) to fire for NEITHER
+    // `show()`/`showInactive()` NOR `hide()`, which left every subscriber
+    // permanently believing the window never opened; the events are kept only
+    // as belt-and-suspenders for external show/hide paths.
+    function notifyHostChanged(hostWc) {
+        if (hostWc === currentHost)
+            return;
+        currentHost = hostWc;
+        for (const handler of [...hostChangedHandlers]) {
+            try {
+                handler(hostWc);
+            }
+            catch (err) {
+                console.warn('[internal-devtools-window] onHostChanged handler threw, other handlers still ran:', err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+    function resizeHostView(hostWindow, view) {
+        try {
+            const [width, height] = hostWindow.getContentSize();
+            view.setBounds({ x: 0, y: 0, width, height });
+        }
+        catch { /* window mid-construction / torn down — next resize event re-fires */ }
+    }
+    // Builds the window + host + DevTools attachment exactly once. A second
+    // call (win already alive) is a no-op — see module doc for why this
+    // attachment is never rebuilt.
+    function buildOnce() {
+        if (win)
+            return;
+        const hostWindow = new BrowserWindow({
+            width: 1000,
+            height: 700,
+            title: '全局调试',
+            show: false,
+        });
+        win = hostWindow;
+        // The window's default `contentView` is a bare WebContentsView tied to
+        // its own (never-loaded) webContents, not a container that accepts
+        // children — mirror main-window/create.ts's pattern: wrap it in a fresh
+        // `View` so the host can be added as a child.
+        const view = new WebContentsView();
+        hostView = view;
+        const container = new View();
+        container.addChildView(view);
+        hostWindow.contentView = container;
+        resizeHostView(hostWindow, view);
+        hostWindow.on('resize', () => resizeHostView(hostWindow, view));
+        // Intercept the user-initiated close (title-bar button, Cmd+W) and hide
+        // instead of destroy — see module doc for why destroying and rebuilding
+        // this attachment cannot be made reliable. `dispose()` bypasses this via
+        // `win.destroy()`, which Electron guarantees does NOT emit 'close'.
+        // EXCEPT during a real app quit: preventDefault() on 'close' while the
+        // app is quitting CANCELS the quit itself (Electron closes every window
+        // as part of quit and aborts if any refuses), stranding the process with
+        // a hidden window — let the native close proceed instead.
+        hostWindow.on('close', (event) => {
+            if (opts?.isAppQuitting?.())
+                return;
+            event.preventDefault();
+            hostWindow.hide();
+            // Push the transition ourselves — the native 'hide' event is not
+            // reliable (see notifyHostChanged's dedup comment).
+            notifyHostChanged(null);
+        });
+        // Any real destruction (quit-time close above, or dispose()'s destroy())
+        // must both release the controller's handle and tell subscribers the
+        // host is gone.
+        hostWindow.on('closed', () => {
+            if (win !== hostWindow)
+                return;
+            win = null;
+            notifyHostChanged(null);
+        });
+        hostWindow.on('hide', () => notifyHostChanged(null));
+        hostWindow.on('show', () => notifyHostChanged(view.webContents));
+        if (!target.webContents.isDestroyed()) {
+            target.webContents.setDevToolsWebContents(view.webContents);
+            target.webContents.openDevTools({ mode: 'detach', activate: false });
+        }
+    }
+    return {
+        open() {
+            buildOnce();
+            // Mirrors main-window/create.ts's exact test-mode rule: `showInactive()`
+            // makes the window visible without activating it (and thus never gives
+            // it OS-level focus), so e2e runs opening this window never steal
+            // foreground focus from whatever the developer running the suite has
+            // open. Production always wants a real show()+focus() — this is the
+            // one button click that's supposed to bring the debug window forward.
+            if (process.env.NODE_ENV === 'test') {
+                win.showInactive();
+            }
+            else {
+                win.show();
+                win.focus();
+            }
+            // Push the transition ourselves — the native 'show' event is not
+            // reliable (see notifyHostChanged's dedup comment); relying on it left
+            // the mirrors permanently unsubscribed on real macOS.
+            if (hostView)
+                notifyHostChanged(hostView.webContents);
+        },
+        dispose() {
+            if (!win)
+                return;
+            const hostWindow = win;
+            // destroy() emits 'closed', whose handler above nulls `win` and
+            // notifies subscribers — the fallback below only covers a window that
+            // was somehow already destroyed without that handler having run.
+            if (!hostWindow.isDestroyed())
+                hostWindow.destroy();
+            if (win === hostWindow) {
+                win = null;
+                notifyHostChanged(null);
+            }
+        },
+        onHostChanged(handler) {
+            hostChangedHandlers.add(handler);
+            // Late-subscriber catch-up (see the interface doc): replayed a
+            // microtask later, never synchronously, and re-validated at fire time —
+            // an unsubscribe or a hide landing before the microtask must win.
+            if (currentHost) {
+                queueMicrotask(() => {
+                    if (!hostChangedHandlers.has(handler))
+                        return;
+                    if (!currentHost)
+                        return;
+                    try {
+                        handler(currentHost);
+                    }
+                    catch (err) {
+                        console.warn('[internal-devtools-window] onHostChanged catch-up handler threw:', err instanceof Error ? err.message : String(err));
+                    }
+                });
+            }
+            return () => { hostChangedHandlers.delete(handler); };
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/main/windows/main-window/create.d.ts

@@ -6,6 +6,14 @@ export interface WindowOptions {
     minWidth?: number;
     minHeight?: number;
     indexHtml: string;
+    /**
+     * Query string appended to the loaded `file://` URL. This is how a window
+     * receives its own bootstrap identity (the workbench window reads the project
+     * it belongs to from here), so the renderer entry knows what to mount without
+     * a round-trip. Survives navigation-hardening: that check matches on the
+     * `file://` prefix only and ignores the query (see navigation-hardening.ts).
+     */
+    query?: Record<string, string>;
     /**
      * Auto-show the window on `ready-to-show` in non-test envs. Defaults to
      * `true`. `false` lets a login-gating host keep the window hidden and call
@@ -13,5 +21,13 @@ export interface WindowOptions {
      */
     autoShow?: boolean;
 }
+/**
+ * Shows `win` the way the current env expects: `showInactive()` in test env
+ * so e2e windows don't steal focus, `show()` otherwise. Shared by this
+ * module's own `ready-to-show` handler and by the workbench window manager's
+ * reveal-after-hook-and-paint gate (`workbench-window.ts`), so the two reveal
+ * paths can never pick different show methods.
+ */
+export declare function revealMainWindow(win: BrowserWindow): void;
 export declare function createMainWindow(opts: WindowOptions): BrowserWindow;
 //# sourceMappingURL=create.d.ts.map

package/dist/main/windows/main-window/create.js

@@ -3,6 +3,19 @@ import path from 'path';
 import { mainPreloadPath } from '../../utils/paths.js';
 import { themeBg } from '../../utils/theme.js';
 import { applyNavigationHardening } from '../navigation-hardening.js';
+/**
+ * Shows `win` the way the current env expects: `showInactive()` in test env
+ * so e2e windows don't steal focus, `show()` otherwise. Shared by this
+ * module's own `ready-to-show` handler and by the workbench window manager's
+ * reveal-after-hook-and-paint gate (`workbench-window.ts`), so the two reveal
+ * paths can never pick different show methods.
+ */
+export function revealMainWindow(win) {
+    if (process.env.NODE_ENV === 'test')
+        win.showInactive();
+    else
+        win.show();
+}
 export function createMainWindow(opts) {
     const mainWindow = new BrowserWindow({
         width: opts.width ?? 1280,
@@ -25,16 +38,11 @@ export function createMainWindow(opts) {
         const isTest = process.env.NODE_ENV === 'test';
         // Visibility is governed by `autoShow` in BOTH envs. A login-gating host
         // opts out via `autoShow: false` and reveals the window itself once auth
-        // passes — don't flash an un-authed window. The env only chooses HOW to
-        // show: test uses showInactive() so e2e windows don't steal focus, prod
-        // uses show(). The framework must never force-show when the host opted
-        // out, in test env either (that would fight the host's own reveal handler).
-        if (opts.autoShow !== false) {
-            if (isTest)
-                mainWindow.showInactive();
-            else
-                mainWindow.show();
-        }
+        // passes — don't flash an un-authed window. The framework must never
+        // force-show when the host opted out, in test env either (that would
+        // fight the host's own reveal handler).
+        if (opts.autoShow !== false)
+            revealMainWindow(mainWindow);
         // Don't auto-open a detached DevTools for the devtools UI shell itself —
         // it's noise for normal use (the mini-app's Console lives in the embedded
         // right-panel DevTools, not here). Opt in via env for debugging the shell.
@@ -46,7 +54,7 @@ export function createMainWindow(opts) {
     // Restrict the main renderer to file:// URLs under the renderer bundle and
     // route every popup through the OS browser. See navigation-hardening.ts.
     applyNavigationHardening(mainWindow.webContents, rendererDir);
-    mainWindow.loadFile(opts.indexHtml);
+    mainWindow.loadFile(opts.indexHtml, opts.query ? { query: opts.query } : undefined);
     const container = new View();
     const mainWebView = mainWindow.contentView;
     container.addChildView(mainWebView);

package/dist/main/windows/main-window/events.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserWindow } from 'electron';
+import { BrowserWindow } from 'electron';
 import type { WorkbenchContext } from '../../services/workbench-context.js';
 import { type Disposable } from '@dimina-kit/electron-deck/main';
 export interface MainWindowEventState {

package/dist/main/windows/main-window/events.js

@@ -1,5 +1,29 @@
-import { globalShortcut } from 'electron';
+import { BrowserWindow, globalShortcut } from 'electron';
 import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
+const DEVTOOLS_ACCELERATOR = 'CommandOrControl+Shift+I';
+let devToolsShortcutHolders = 0;
+/**
+ * Claims a share of the ONE process-wide DevTools accelerator. `globalShortcut`
+ * is a process singleton: a per-window registration is refused for every window
+ * after the first, which would give that first window the shortcut for the
+ * whole app and kill it outright when that window closed. So the accelerator is
+ * registered once, opens whichever window is focused when it is pressed, and is
+ * released only when the last holder lets go — a later window can then claim it
+ * again. `unregisterAll()` in lifecycle stays as a process-exit safety net.
+ */
+function acquireDevToolsShortcut() {
+    if (devToolsShortcutHolders === 0) {
+        globalShortcut.register(DEVTOOLS_ACCELERATOR, () => {
+            BrowserWindow.getFocusedWindow()?.webContents.openDevTools({ mode: 'detach' });
+        });
+    }
+    devToolsShortcutHolders += 1;
+    return toDisposable(() => {
+        devToolsShortcutHolders -= 1;
+        if (devToolsShortcutHolders === 0)
+            globalShortcut.unregister(DEVTOOLS_ACCELERATOR);
+    });
+}
 export function wireMainWindowEvents(win, state = {}) {
     const registry = new DisposableRegistry();
     const mainWebView = win.contentView.children[0];
@@ -24,18 +48,7 @@ export function wireMainWindowEvents(win, state = {}) {
             win.removeListener('close', onCloseHandler);
         }));
     }
-    // DevTools shortcut: scoped to this main window so its disposal is tied
-    // to ctx.registry. `unregisterAll()` in lifecycle remains as a process-exit
-    // safety net.
-    const devToolsAccelerator = 'CommandOrControl+Shift+I';
-    const registered = globalShortcut.register(devToolsAccelerator, () => {
-        win.webContents.openDevTools({ mode: 'detach' });
-    });
-    if (registered) {
-        registry.add(toDisposable(() => {
-            globalShortcut.unregister(devToolsAccelerator);
-        }));
-    }
+    registry.add(acquireDevToolsShortcut());
     return registry;
 }
 //# sourceMappingURL=events.js.map

package/dist/main/windows/main-window/index.d.ts

@@ -1,4 +1,4 @@
-export { createMainWindow } from './create.js';
+export { createMainWindow, revealMainWindow } from './create.js';
 export type { WindowOptions } from './create.js';
 export { wireMainWindowEvents } from './events.js';
 export type { MainWindowEventState } from './events.js';

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

@@ -1,3 +1,3 @@
-export { createMainWindow } from './create.js';
+export { createMainWindow, revealMainWindow } from './create.js';
 export { wireMainWindowEvents } from './events.js';
 //# sourceMappingURL=index.js.map

package/dist/main/windows/service-host-window/create.d.ts

@@ -1,93 +1,2 @@
-import { BrowserWindow } from 'electron';
-import type { ServiceHostSpec } from '../../services/service-host-pool/pool.js';
-/**
- * Default service-host partition when no project `appId` is supplied (the
- * pre-warm pool's shared, isolation-UNAWARE session — see `serviceHostSpec`).
- * Per-project service hosts get a `persist:miniapp-<key>` partition instead so
- * their localStorage/cookies are shared with that project's render side only.
- */
-export declare const SERVICE_HOST_PARTITION = "persist:simulator";
-/** Absolute path to the service-host preload (loaded at runtime by path). */
-export declare const serviceHostPreloadPath: string;
-export interface ServiceHostWindowOptions {
-    bridgeId: string;
-    appId: string;
-    /** Current project root. Folded into the session partition (with appId) so a
-     * different project declaring the same appId gets isolated storage. Omitted on
-     * the pre-warm pool path (no project known yet → shared partition). */
-    projectPath?: string;
-    pagePath: string;
-    pkgRoot: string;
-    root?: string;
-    resourceBaseUrl: string;
-    hostEnvSnapshot?: Record<string, unknown>;
-    /**
-     * Custom API namespace names (host config `apiNamespaces`, e.g. `['qd']`).
-     * Encoded into the spawn URL so the service-host preload can install them as
-     * `globalThis.__diminaApiNamespaces` before service.js evaluates — without
-     * which page logic referencing `qd.*` throws `ReferenceError: qd is not defined`.
-     */
-    apiNamespaces?: string[];
-    /**
-     * Observes a spawn-navigation `loadURL` rejection (NOT encoded into the
-     * spawn URL). Without it the fresh-window path swallows the failure entirely
-     * — `did-finish-load` never fires, the session hangs, and the only signal is
-     * the launch watchdog's late timeout instead of the real cause.
-     */
-    onLoadFailed?: (err: unknown) => void;
-}
-/**
- * Construct an (un-navigated) service-host BrowserWindow. Split out from
- * `createServiceHostWindow` so a pre-warm pool can build the window once and
- * navigate it per spawn (the spawn context lives in the URL — see
- * `buildServiceHostSpawnUrl`). The process-model flags here are the contract
- * the service-host preload depends on (it `require('electron')` and writes
- * globals onto the page realm).
- */
-export declare function constructServiceHostWindow(opts?: {
-    appId?: string;
-    partition?: string;
-}): BrowserWindow;
-/**
- * Build the file:// spawn URL carrying the per-spawn context the preload reads
- * from `location.search` at eval time (bridgeId/appId/pagePath/pkgRoot/
- * resourceBaseUrl/hostEnv).
- */
-export declare function buildServiceHostSpawnUrl(opts: ServiceHostWindowOptions): string;
-/**
- * Navigate a (constructed or pooled) service-host window to its spawn URL. The
- * preload re-evaluates on this navigation, rebuilding `__diminaSpawnContext`.
- * Returns the load promise (resolves on did-finish-load). Attaches the dev-only
- * detached-DevTools hook, matching the original behavior.
- *
- * A `loadURL` rejection is swallowed — the pooled-window recycle path expects
- * a failed navigation not to reject the caller — but `opts.onLoadFailed`, when
- * given, still observes the original rejection reason (routed by the caller
- * into the diagnostics bus) before this resolves.
- */
-export declare function navigateServiceHost(win: BrowserWindow, url: string, opts?: {
-    onLoadFailed?: (err: unknown) => void;
-}): Promise<void>;
-/**
- * The spec a `ServiceHostPool` uses to pre-warm service-host windows. Keeps the
- * pooled window byte-equivalent to `constructServiceHostWindow`'s output, and
- * opts out of the reset storage-clear because the service host shares its
- * session with live projects (see ServiceHostSpec docs).
- *
- * KNOWN BLOCKER (intentional): the pre-warm pool is NOT per-project isolation
- * aware. It warms windows on ONE `defaultSpec` partition before any project is
- * known, so a pooled window cannot carry a project-derived partition — handing
- * one project's warmed window to another project would cross-contaminate
- * storage. Therefore the pool's `defaultSpec` (and pooled `acquire`) call this
- * with NO appId → the shared `persist:simulator` partition; per-project
- * isolation only applies on the default (non-pooled) `createServiceHostWindow`
- * path, which passes the project's appId. Reconciling pooling with per-project
- * partitions (e.g. per-partition sub-pools) is out of scope for this change.
- */
-export declare function serviceHostSpec(appId?: string, projectPath?: string): ServiceHostSpec;
-/**
- * Construct + navigate a fresh service-host window (the non-pool path).
- * Behavior-identical to the pre-refactor implementation.
- */
-export declare function createServiceHostWindow(opts: ServiceHostWindowOptions): BrowserWindow;
+export * from '@dimina-kit/electron-runtime/main/service-host-window';
 //# sourceMappingURL=create.d.ts.map

package/dist/main/windows/service-host-window/create.js

@@ -1,155 +1,2 @@
-import { app, BrowserWindow } from 'electron';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { devtoolsPackageRoot } from '../../utils/paths.js';
-import { configureMiniappSession, miniappPartition, SHARED_MINIAPP_PARTITION } from '../../services/views/miniapp-partition.js';
-/**
- * Default service-host partition when no project `appId` is supplied (the
- * pre-warm pool's shared, isolation-UNAWARE session — see `serviceHostSpec`).
- * Per-project service hosts get a `persist:miniapp-<key>` partition instead so
- * their localStorage/cookies are shared with that project's render side only.
- */
-export const SERVICE_HOST_PARTITION = SHARED_MINIAPP_PARTITION;
-/** Absolute path to the service-host preload (loaded at runtime by path). */
-export const serviceHostPreloadPath = path.join(devtoolsPackageRoot, 'dist/service-host/preload.cjs');
-const serviceHostHtmlPath = path.join(devtoolsPackageRoot, 'dist/service-host/service.html');
-/**
- * Construct an (un-navigated) service-host BrowserWindow. Split out from
- * `createServiceHostWindow` so a pre-warm pool can build the window once and
- * navigate it per spawn (the spawn context lives in the URL — see
- * `buildServiceHostSpawnUrl`). The process-model flags here are the contract
- * the service-host preload depends on (it `require('electron')` and writes
- * globals onto the page realm).
- */
-export function constructServiceHostWindow(opts = {}) {
-    const partition = opts.partition ?? SERVICE_HOST_PARTITION;
-    // Apply the simulator runtime's protocol handlers + webRequest policies to
-    // THIS project's session before the window loads. Idempotent per partition.
-    configureMiniappSession(partition);
-    return new BrowserWindow({
-        width: 980,
-        height: 720,
-        show: false,
-        title: opts.appId ? `Dimina Service Host: ${opts.appId}` : 'Dimina Service Host',
-        webPreferences: {
-            partition,
-            nodeIntegration: false,
-            contextIsolation: false,
-            sandbox: false,
-            preload: serviceHostPreloadPath,
-            devTools: true,
-        },
-    });
-}
-/**
- * Build the file:// spawn URL carrying the per-spawn context the preload reads
- * from `location.search` at eval time (bridgeId/appId/pagePath/pkgRoot/
- * resourceBaseUrl/hostEnv).
- */
-export function buildServiceHostSpawnUrl(opts) {
-    const url = new URL(pathToFileURL(serviceHostHtmlPath).toString());
-    url.searchParams.set('bridgeId', opts.bridgeId);
-    url.searchParams.set('appId', opts.appId);
-    url.searchParams.set('pagePath', opts.pagePath);
-    url.searchParams.set('pkgRoot', opts.pkgRoot);
-    url.searchParams.set('root', opts.root || 'main');
-    url.searchParams.set('resourceBaseUrl', opts.resourceBaseUrl);
-    if (opts.hostEnvSnapshot) {
-        // Encode the resolved host-env so preload can hydrate
-        // `__diminaSpawnContext.hostEnvSnapshot` before service.js loads.
-        // Without this, sync-impls/system-info.ts falls back to generic defaults.
-        url.searchParams.set('hostEnv', encodeURIComponent(JSON.stringify(opts.hostEnvSnapshot)));
-    }
-    if (opts.apiNamespaces && opts.apiNamespaces.length > 0) {
-        // CSV of namespace names; the preload reads this back into
-        // `globalThis.__diminaApiNamespaces`. URLSearchParams round-trips the comma.
-        url.searchParams.set('apiNamespaces', opts.apiNamespaces.join(','));
-    }
-    return url.toString();
-}
-/**
- * Navigate a (constructed or pooled) service-host window to its spawn URL. The
- * preload re-evaluates on this navigation, rebuilding `__diminaSpawnContext`.
- * Returns the load promise (resolves on did-finish-load). Attaches the dev-only
- * detached-DevTools hook, matching the original behavior.
- *
- * A `loadURL` rejection is swallowed — the pooled-window recycle path expects
- * a failed navigation not to reject the caller — but `opts.onLoadFailed`, when
- * given, still observes the original rejection reason (routed by the caller
- * into the diagnostics bus) before this resolves.
- */
-export function navigateServiceHost(win, url, opts) {
-    const loaded = Promise.resolve(win.loadURL(url)).then(() => undefined, (err) => {
-        opts?.onLoadFailed?.(err);
-        return undefined;
-    });
-    if (!app.isPackaged && process.env.NODE_ENV !== 'test') {
-        // Recycled pooled windows get navigated repeatedly. A `once` hook that never
-        // fires (the spawn was disposed before its service.html settled) stays on the
-        // reused webContents and the next spawn's hook fires alongside it → DevTools
-        // can open twice and stale hooks accumulate. Remove the prior hook before
-        // attaching a fresh one. (Audit A6; dev-only.)
-        const w = win;
-        if (w.__diminaDevToolsHook) {
-            try {
-                win.webContents.removeListener('did-finish-load', w.__diminaDevToolsHook);
-            }
-            catch { /* wc gone */ }
-        }
-        const hook = () => {
-            // URL-guard so a reset's about:blank load doesn't pop DevTools.
-            if (!win.isDestroyed() && win.webContents.getURL().includes('service.html')) {
-                win.webContents.openDevTools({ mode: 'detach' });
-            }
-        };
-        w.__diminaDevToolsHook = hook;
-        win.webContents.once('did-finish-load', hook);
-    }
-    return loaded;
-}
-/**
- * The spec a `ServiceHostPool` uses to pre-warm service-host windows. Keeps the
- * pooled window byte-equivalent to `constructServiceHostWindow`'s output, and
- * opts out of the reset storage-clear because the service host shares its
- * session with live projects (see ServiceHostSpec docs).
- *
- * KNOWN BLOCKER (intentional): the pre-warm pool is NOT per-project isolation
- * aware. It warms windows on ONE `defaultSpec` partition before any project is
- * known, so a pooled window cannot carry a project-derived partition — handing
- * one project's warmed window to another project would cross-contaminate
- * storage. Therefore the pool's `defaultSpec` (and pooled `acquire`) call this
- * with NO appId → the shared `persist:simulator` partition; per-project
- * isolation only applies on the default (non-pooled) `createServiceHostWindow`
- * path, which passes the project's appId. Reconciling pooling with per-project
- * partitions (e.g. per-partition sub-pools) is out of scope for this change.
- */
-export function serviceHostSpec(appId, projectPath) {
-    return {
-        // Per-project partition when an appId is known (so this project's service
-        // host shares storage ONLY with its own render side); the shared partition
-        // for the pre-warm pool's default spec (no appId — see KNOWN BLOCKER below).
-        // projectPath joins the key so same-appId/different-path projects isolate;
-        // it must match the simulator WCV's partition (view-manager passes the same
-        // (appId, projectPath)).
-        partition: appId ? miniappPartition(appId, projectPath) : SERVICE_HOST_PARTITION,
-        preloadPath: serviceHostPreloadPath,
-        size: { width: 980, height: 720 },
-        contextIsolation: false,
-        sandbox: false,
-        nodeIntegration: false,
-        clearStorageOnReset: false,
-    };
-}
-/**
- * Construct + navigate a fresh service-host window (the non-pool path).
- * Behavior-identical to the pre-refactor implementation.
- */
-export function createServiceHostWindow(opts) {
-    // Default (non-pooled) path: pin the service host to THIS project's partition
-    // so its logic-layer localStorage/cookies are shared with the project's render
-    // side only, never with other projects.
-    const win = constructServiceHostWindow({ appId: opts.appId, partition: miniappPartition(opts.appId, opts.projectPath) });
-    void navigateServiceHost(win, buildServiceHostSpawnUrl(opts), { onLoadFailed: opts.onLoadFailed });
-    return win;
-}
+export * from '@dimina-kit/electron-runtime/main/service-host-window';
 //# sourceMappingURL=create.js.map