@dimina-kit/devtools 0.4.0-dev.20260729062524 → 0.4.0-dev.20260801163345

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

@@ -1,4 +1,5 @@
 import type { BrowserWindow } from 'electron';
+import { type RuntimeContext, type RuntimeEvents } from '@dimina-kit/electron-runtime/main/runtime-context';
 import type { CompilationAdapter, CustomFileTypes, WorkbenchConfig } from '../../shared/types.js';
 import type { BridgeRouterHandle } from '../ipc/bridge-router.js';
 import type { ConsoleForwarder } from './console-forward/index.js';
@@ -26,7 +27,7 @@ import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
  */
-export interface WorkbenchContext {
+export interface WorkbenchContext extends RuntimeContext {
     adapter: CompilationAdapter;
     /** Absolute path to the preload script loaded into the simulator webview */
     preloadPath: string;
@@ -131,6 +132,8 @@ export interface WorkbenchContext {
     simulatorUiExtensions: SimulatorUiExtensionRegistry;
     /** Aggregates dispose handlers for every IPC handler, listener, watcher, and CDP session registered by the workbench. */
     registry: DisposableRegistry;
+    /** Runtime-domain events consumed by optional DevTools panels and renderer notifications. */
+    events: RuntimeEvents;
     /**
      * Per-webContents connection registry. Each trusted webContents (main window,
      * overlay views, native simulator/render guests) is one `Connection` that

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

@@ -1,3 +1,4 @@
+import { createRuntimeEvents, } from '@dimina-kit/electron-runtime/main/runtime-context';
 import { createCdpSessionBroker } from './cdp-session/index.js';
 import { createConnectionRegistry, DisposableRegistry, } from '@dimina-kit/electron-deck/main';
 import { createWorkbenchSenderPolicy } from '../utils/sender-policy.js';
@@ -15,9 +16,11 @@ import { createSimulatorApiRegistry, } from './simulator/custom-apis.js';
 import { createSimulatorUiExtensionRegistry, } from './simulator/ui-extensions.js';
 import { resolveTemplates, sanitizeTemplates } from './projects/templates.js';
 import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
+import { runtimeAssetPaths } from '../utils/paths.js';
 export function createWorkbenchContext(opts) {
     const ctx = {
         adapter: opts.adapter ?? defaultAdapter,
+        assets: runtimeAssetPaths,
         preloadPath: opts.preloadPath,
         rendererDir: opts.rendererDir,
         apiNamespaces: opts.apiNamespaces ?? [],
@@ -26,6 +29,20 @@ export function createWorkbenchContext(opts) {
         brandingProvider: opts.brandingProvider,
     };
     ctx.registry = new DisposableRegistry();
+    ctx.events = createRuntimeEvents();
+    ctx.registry.add(ctx.events.on('session-status', (payload) => {
+        ctx.notify?.sessionRuntimeStatus(payload);
+    }));
+    ctx.registry.add(ctx.events.on('app-data-evict', ({ appId, bridgeId }) => {
+        ctx.appData?.evictBridge(appId, bridgeId);
+    }));
+    ctx.registry.add(ctx.events.on('app-data-message', ({ appId, message }) => {
+        ctx.appData?.onServiceToRender(appId, message);
+    }));
+    ctx.registry.add(ctx.events.on('storage-changed', ({ appId, change }) => {
+        ctx.onServiceStorageChanged?.(appId, change);
+    }));
+    ctx.registry.add(() => ctx.events.clear());
     // Empty connection registry as a first-class context field. Connections are
     // acquired by real wiring points (app bootstrap, view-manager endpoints),
     // NOT here — the constructor stays side-effect-free so focused unit tests can

package/dist/main/utils/ipc-registry.d.ts

@@ -1,6 +1,6 @@
-import type { IpcMainEvent, WebContents } from 'electron';
+import type { IpcMainEvent } from 'electron';
 import { ipcMain } from 'electron';
-import { type Disposable } from '@dimina-kit/electron-deck/main';
+import { type Disposable, type IpcSenderPolicy } from '@dimina-kit/electron-deck/main';
 type HandleFn = Parameters<typeof ipcMain.handle>[1];
 type ListenerFn = Parameters<typeof ipcMain.on>[1];
 /**
@@ -9,7 +9,25 @@ type ListenerFn = Parameters<typeof ipcMain.on>[1];
  * Returns true when the calling WebContents is allowed to invoke / emit on
  * the channel, false otherwise.
  */
-export type SenderPolicy = (sender: WebContents) => boolean;
+export type SenderPolicy = IpcSenderPolicy;
+/**
+ * Defense-in-depth frame check (sits alongside the sender white-list). A trusted
+ * webContents could embed a sub-frame of arbitrary origin; only its top (main)
+ * frame should reach gated IPC, so a sub-frame can't spoof the trusted sender.
+ *
+ * Verified on Electron 41 that `event.senderFrame` is reliably present on
+ * invoke / send / sendSync — including the editor's `beforeunload` sendSync
+ * write — and equals `sender.mainFrame` for top-frame traffic, so this never
+ * mis-rejects legitimate callers.
+ *
+ * Fail-closed on a null frame for REAL events: a sub-frame can send a message
+ * and immediately navigate/destroy itself, so by delivery time `senderFrame`
+ * resolves to null — allowing that would let the navigate-after-send trick
+ * bypass the boundary. A real Electron event always exposes the `senderFrame`
+ * property and `sender.mainFrame`, so we can tell a real event (frame-modeled,
+ * possibly null) from a frame-unaware unit-test stub (neither present) and only
+ * skip the check for the latter (the sender-id white-list still gates tests).
+ */
 /**
  * Tiny fluent helper that wraps every `ipcMain.handle` / `ipcMain.on` with a
  * matching removeHandler/removeListener registered into an internal registry.

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

@@ -1,4 +1,5 @@
 import { ipcMain } from 'electron';
+import { isMainFrameIpcSender, } from '@dimina-kit/electron-deck/main';
 import { IpcValidationError } from './ipc-schema.js';
 import { createLogger } from './logger.js';
 const log = createLogger('ipc');
@@ -29,23 +30,24 @@ function summarizeSender(sender) {
     const url = sender.getURL();
     return `id=${sender.id} ${url.slice(0, 120)}`;
 }
-function isMainFrameSender(event) {
-    // Read via loose casts: the Electron types declare these always-present, but
-    // unit-test stubs legitimately omit them — and real events can carry a null
-    // senderFrame after navigation/destruction.
-    const frame = event.senderFrame;
-    const main = event.sender.mainFrame;
-    // Frame-unaware stub (NEITHER field modeled) → not a real frame boundary; the
-    // sender-id white-list is the gate. Real events always have both, so they fall
-    // through to the strict check; a partial/malformed event (only one field) also
-    // falls through and fail-closes below rather than escaping here.
-    if (frame === undefined && main === undefined)
-        return true;
-    // Real event, unresolvable frame (navigate-after-send / destroyed) → reject.
-    if (frame == null || main == null)
-        return false;
-    return frame.routingId === main.routingId && frame.processId === main.processId;
-}
+/**
+ * Defense-in-depth frame check (sits alongside the sender white-list). A trusted
+ * webContents could embed a sub-frame of arbitrary origin; only its top (main)
+ * frame should reach gated IPC, so a sub-frame can't spoof the trusted sender.
+ *
+ * Verified on Electron 41 that `event.senderFrame` is reliably present on
+ * invoke / send / sendSync — including the editor's `beforeunload` sendSync
+ * write — and equals `sender.mainFrame` for top-frame traffic, so this never
+ * mis-rejects legitimate callers.
+ *
+ * Fail-closed on a null frame for REAL events: a sub-frame can send a message
+ * and immediately navigate/destroy itself, so by delivery time `senderFrame`
+ * resolves to null — allowing that would let the navigate-after-send trick
+ * bypass the boundary. A real Electron event always exposes the `senderFrame`
+ * property and `sender.mainFrame`, so we can tell a real event (frame-modeled,
+ * possibly null) from a frame-unaware unit-test stub (neither present) and only
+ * skip the check for the latter (the sender-id white-list still gates tests).
+ */
 /**
  * Tiny fluent helper that wraps every `ipcMain.handle` / `ipcMain.on` with a
  * matching removeHandler/removeListener registered into an internal registry.
@@ -84,7 +86,7 @@ export class IpcRegistry {
         const guarded = policy
             ? async (event, ...args) => {
                 const sender = event.sender;
-                if (!policy(sender) || !isMainFrameSender(event)) {
+                if (!policy(sender) || !isMainFrameIpcSender(event)) {
                     console.warn(`[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`);
                     throw new Error(`IPC sender rejected for channel ${channel}`);
                 }
@@ -106,26 +108,27 @@ export class IpcRegistry {
     handleSync(channel, fn) {
         const policy = this.policy;
         const listener = (event, ...args) => {
+            const syncEvent = event;
             // Everything — including the policy check — runs inside the try so EVERY
             // path sets `event.returnValue`. sendSync blocks the renderer until it is
             // set, so an unset value (e.g. a throwing policy fn) would hang the
             // renderer forever; the catch guarantees a sentinel instead.
             try {
-                if (policy && (!policy(event.sender) || !isMainFrameSender(event))) {
+                if (policy && (!policy(event.sender) || !isMainFrameIpcSender(event))) {
                     console.warn(`[ipc] sender rejected for channel '${channel}' (${summarizeSender(event.sender)})`);
-                    event.returnValue = {
+                    syncEvent.returnValue = {
                         ok: false,
                         code: 'EREJECTED',
                         message: `IPC sender rejected for channel ${channel}`,
                     };
                     return;
                 }
-                event.returnValue = fn(event, ...args);
+                syncEvent.returnValue = fn(event, ...args);
             }
             catch (err) {
                 reportListenerError(channel, err);
                 const code = err?.code;
-                event.returnValue = {
+                syncEvent.returnValue = {
                     ok: false,
                     code: typeof code === 'string' ? code : 'EUNKNOWN',
                     message: err instanceof Error ? err.message : String(err),
@@ -156,7 +159,7 @@ export class IpcRegistry {
         const guarded = policy
             ? (event, ...args) => {
                 const sender = event.sender;
-                if (!policy(sender) || !isMainFrameSender(event)) {
+                if (!policy(sender) || !isMainFrameIpcSender(event)) {
                     console.warn(`[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`);
                     return;
                 }

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

@@ -32,6 +32,20 @@ export declare const mainPreloadPath: string;
  */
 export declare const hostToolbarRuntimePreloadPath: string;
 export declare const simulatorDir: string;
+/**
+ * DevTools builds its own copy of every native mini-app runtime asset. Pin the
+ * shared runtime bridge to that copy so a packaged client never depends on the
+ * standalone npm package's optional asset assembly step.
+ */
+export declare const runtimeAssetPaths: {
+    root: string;
+    simulatorDir: string;
+    simulatorPreloadPath: string;
+    renderHostHtmlPath: string;
+    renderHostPreloadPath: string;
+    serviceHostHtmlPath: string;
+    serviceHostPreloadPath: string;
+};
 export declare function getRendererDir(): string;
 export declare function getPreloadDir(): string;
 export declare function getRendererHtml(filename: string): string;

package/dist/main/utils/paths.js

@@ -60,6 +60,20 @@ export const mainPreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/wind
  */
 export const hostToolbarRuntimePreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/windows/host-toolbar-runtime.cjs');
 export const simulatorDir = path.join(devtoolsPackageRoot, 'dist/simulator');
+/**
+ * DevTools builds its own copy of every native mini-app runtime asset. Pin the
+ * shared runtime bridge to that copy so a packaged client never depends on the
+ * standalone npm package's optional asset assembly step.
+ */
+export const runtimeAssetPaths = {
+    root: path.join(devtoolsPackageRoot, 'dist'),
+    simulatorDir,
+    simulatorPreloadPath: path.join(devtoolsPackageRoot, 'dist/preload/windows/simulator.cjs'),
+    renderHostHtmlPath: path.join(devtoolsPackageRoot, 'dist/render-host/pageFrame.html'),
+    renderHostPreloadPath: path.join(devtoolsPackageRoot, 'dist/render-host/preload.cjs'),
+    serviceHostHtmlPath: path.join(devtoolsPackageRoot, 'dist/service-host/service.html'),
+    serviceHostPreloadPath: path.join(devtoolsPackageRoot, 'dist/service-host/preload.cjs'),
+};
 export function getRendererDir() {
     return rendererDir;
 }

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