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

package/dist/main/services/dimina-resource-server.js

@@ -1,99 +1,2 @@
-import http from 'node:http';
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const MIME_TYPES = {
-    '.css': 'text/css; charset=utf-8',
-    '.html': 'text/html; charset=utf-8',
-    '.js': 'text/javascript; charset=utf-8',
-    '.json': 'application/json; charset=utf-8',
-    '.map': 'application/json; charset=utf-8',
-    '.svg': 'image/svg+xml',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.webp': 'image/webp',
-    '.wasm': 'application/wasm',
-};
-export async function startDiminaResourceServer(rootDir) {
-    const root = path.resolve(rootDir);
-    const server = http.createServer((req, res) => {
-        void handleRequest(root, req, res);
-    });
-    await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => {
-            server.off('error', reject);
-            resolve();
-        });
-    });
-    const address = server.address();
-    return {
-        baseUrl: `http://127.0.0.1:${address.port}/`,
-        close() {
-            return new Promise((resolve, reject) => {
-                server.close((err) => err ? reject(err) : resolve());
-            });
-        },
-    };
-}
-async function handleRequest(root, req, res) {
-    setCorsHeaders(res);
-    if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return;
-    }
-    if (req.method !== 'GET' && req.method !== 'HEAD') {
-        res.writeHead(405);
-        res.end('Method Not Allowed');
-        return;
-    }
-    const url = new URL(req.url ?? '/', 'http://127.0.0.1');
-    const filePath = resolveContainedPath(root, decodeURIComponent(url.pathname));
-    if (!filePath) {
-        res.writeHead(403);
-        res.end('Forbidden');
-        return;
-    }
-    try {
-        const stat = await fs.promises.stat(filePath);
-        if (!stat.isFile()) {
-            res.writeHead(404);
-            res.end('Not Found');
-            return;
-        }
-        res.writeHead(200, {
-            'content-type': MIME_TYPES[path.extname(filePath)] ?? 'application/octet-stream',
-            'content-length': stat.size,
-            'cache-control': 'no-store',
-        });
-        if (req.method === 'HEAD') {
-            res.end();
-            return;
-        }
-        fs.createReadStream(filePath).pipe(res);
-    }
-    catch {
-        res.writeHead(404);
-        res.end('Not Found');
-    }
-}
-function resolveContainedPath(root, pathname) {
-    const relative = pathname.replace(/^\/+/, '') || 'index.html';
-    const resolved = path.resolve(root, relative);
-    if (resolved !== root && !resolved.startsWith(root + path.sep))
-        return null;
-    return resolved;
-}
-function setCorsHeaders(res) {
-    res.setHeader('access-control-allow-origin', '*');
-    res.setHeader('access-control-allow-headers', '*');
-    res.setHeader('access-control-allow-methods', 'GET,HEAD,OPTIONS');
-    res.setHeader('cross-origin-resource-policy', 'cross-origin');
-}
-export function toSourceUrl(filePath) {
-    return pathToFileURL(filePath).toString();
-}
+export * from '@dimina-kit/electron-runtime/main/dimina-resource-server';
 //# sourceMappingURL=dimina-resource-server.js.map

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

@@ -11,10 +11,14 @@
  */
 import CDP from 'chrome-remote-interface';
 import { DEFAULT_CDP_PORT } from '../../../shared/constants.js';
+import { DMB_PAGEFRAME_DOC_NAME } from '../../../shared/dmb-resource-url.js';
 const SIMULATOR_URL_PATTERN = 'localhost:7788';
 // Native-host: the real mini-app page runs in a nested render-host <webview>
 // guest whose CDP target URL carries the render frame + the page's bridgeId.
-const RENDER_GUEST_PATTERN = 'pageFrame.html';
+// Import the shared reserved doc name rather than hand-writing a second
+// literal — that duplication is exactly what let this pattern drift out of
+// sync with the actual document URL shape (dmb-resource-url.ts).
+const RENDER_GUEST_PATTERN = DMB_PAGEFRAME_DOC_NAME;
 const MAX_BUFFER = 500;
 const RECONNECT_INTERVAL_MS = 3000;
 let cdpPort = DEFAULT_CDP_PORT;

package/dist/main/services/network-forward/index.d.ts

@@ -68,13 +68,16 @@
  *     Chrome DevTools window) self-heals via the lease's `onDetach` — capture
  *     re-wires itself even though `attachRenderGuest` is only ever called ONCE
  *     per guest (at webview creation).
- *  ⚠️ NOT observable by any `webContents.debugger`: a request a host module issues
- *     directly from the MAIN process. Those need an explicit `report()` call
- *     (exposed below; it uses the console fallback path).
+ *  ⚠️ NOT observable by any `webContents.debugger`: traffic a host module issues
+ *     directly from the MAIN process. Plain requests need an explicit `report()`
+ *     call (console fallback path); `wx.connectSocket` sockets (Node `ws`
+ *     transport) arrive as trace events via `reportWebSocketTrace` and are
+ *     synthesized into `Network.webSocket*` CDP messages (see websocket.ts).
  */
 import type { WebContents } from 'electron';
 import { type ConnectionRegistry, type Disposable } from '@dimina-kit/electron-deck/main';
 import { type CdpSessionBroker } from '../cdp-session/index.js';
+import type { NativeWebSocketTrace } from '../../ipc/bridge-router.js';
 /**
  * Namespace prefix of every virtual requestId this forwarder injects into the
  * DevTools front-end. SINGLE SOURCE for the literal: the front-end outbound
@@ -215,6 +218,15 @@ export interface NetworkForwarder extends Disposable {
      * (e.g. a main-process direct send). Uses the console fallback sink.
      */
     report(record: NetworkRequestRecord): void;
+    /**
+     * Surface one main-process WebSocket trace event (wx.connectSocket traffic
+     * lives on the Node `ws` transport, invisible to any debugger) as a
+     * synthesized `Network.webSocket*` CDP event, injected through the SAME
+     * channels as forwarded simulator traffic: the global mirror unfiltered,
+     * plus the user-facing native sink when the socket's url classified
+     * user-facing. Best-effort like every injection point — never throws.
+     */
+    reportWebSocketTrace(sessionId: string, event: NativeWebSocketTrace): void;
     /**
      * Body/post-data lookups for the virtual requestIds this forwarder injected,
      * backed by the loadingFinished-time prefetch cache. Keyed by virtual id, so

package/dist/main/services/network-forward/index.js

@@ -6,6 +6,7 @@ import { PROBE_DEVTOOLS_API, MAX_SINGLE_DISPATCH_CHARS, CHUNK_CHARS, buildChunke
 import { createCdpSessionBroker } from '../cdp-session/index.js';
 import { isUserFacingRequest } from './user-facing.js';
 import { installGlobalNetworkBodyGate } from './global-body-gate.js';
+import { WebSocketTraceSynthesizer } from './websocket.js';
 /**
  * Namespace prefix of every virtual requestId this forwarder injects into the
  * DevTools front-end. SINGLE SOURCE for the literal: the front-end outbound
@@ -553,14 +554,17 @@ export function createNetworkForwarder(bridge) {
         queueMicrotask(flushDispatch);
     }
     /** Trim the native queue to its cap, preferring to keep request-opening events.
-     * Active requests' first events (requestWillBeSent / ...ExtraInfo) are retained
-     * so later responseReceived/loadingFinished never become orphans in the panel;
-     * we drop the oldest NON-opening (low-value / completion) events first. */
+     * Active requests' first events (requestWillBeSent / ...ExtraInfo /
+     * webSocketCreated) are retained so later responseReceived/loadingFinished/
+     * webSocket* events never become orphans in the panel (the front-end
+     * silently drops events for an unknown requestId); we drop the oldest
+     * NON-opening (low-value / completion) events first. */
     function trimQueue() {
         if (dispatchQueue.length <= MAX_DISPATCH_QUEUE)
             return;
         const isOpener = (json) => json.includes('"Network.requestWillBeSent"')
-            || json.includes('"Network.requestWillBeSentExtraInfo"');
+            || json.includes('"Network.requestWillBeSentExtraInfo"')
+            || json.includes('"Network.webSocketCreated"');
         // First pass: drop oldest non-opener events.
         const kept = [];
         let over = dispatchQueue.length - MAX_DISPATCH_QUEUE;
@@ -1293,6 +1297,27 @@ export function createNetworkForwarder(bridge) {
         if (ownsBroker)
             broker.dispose();
     });
+    // ── Main-process WebSocket trace → synthesized Network.webSocket* CDP ─────
+    // One synthesizer for the forwarder's lifetime: its virtual-id epoch keeps
+    // `dimina:ws:` ids collision-free across simulator re-attaches, and its
+    // per-socket verdict cache mirrors resolveUserFacing's decide-once rule.
+    const wsSynthesizer = new WebSocketTraceSynthesizer({
+        epoch: String(Date.now()),
+        internalOrigins: () => [bridge.getResourceServerBaseUrl?.(), bridge.getSimulatorServerBaseUrl?.()],
+    });
+    function reportWebSocketTrace(sessionId, event) {
+        if (disposed)
+            return;
+        const message = wsSynthesizer.synthesize(sessionId, event);
+        if (!message)
+            return;
+        // Global mirror first (full, unfiltered), then the user-facing native
+        // sink gated on the created-time verdict — the same routing
+        // wireNetworkCapture's onMessage uses for simulator traffic.
+        dispatchToGlobal(message.method, message.params);
+        if (message.userFacing)
+            enqueueNative(message.method, message.params);
+    }
     return {
         attachSimulator,
         detachSimulator,
@@ -1302,6 +1327,7 @@ export function createNetworkForwarder(bridge) {
         // report() has no observing debugger, so there's no live CDP event to push
         // natively — surface it via the console fallback line.
         report: (record) => forwardToConsole(record),
+        reportWebSocketTrace,
         bodies: {
             getResponseBody: (requestId) => bodyCache.lookup(requestId),
             getRequestPostData: (requestId) => postDataCache.lookup(requestId),

package/dist/main/services/network-forward/websocket.d.ts

@@ -0,0 +1,36 @@
+import type { NativeWebSocketTrace } from '../../ipc/bridge-router.js';
+/** One CDP message ready for `DevToolsAPI.dispatchMessage` injection. */
+export interface SynthesizedWebSocketMessage {
+    method: string;
+    params: unknown;
+    /**
+     * The verdict `isUserFacingRequest` produced for this socket's url at
+     * `created` time, cached for the socket's whole lifetime — every later
+     * event reuses it (they carry no url of their own). The user-facing sink
+     * gates on this; the global mirror ignores it.
+     */
+    userFacing: boolean;
+}
+export interface WebSocketSynthesizerOptions {
+    /** Per-forwarder instance tag keeping virtual ids collision-free. */
+    epoch: string;
+    /**
+     * Origins the app itself serves (resource server / simulator shell), the
+     * same inputs `resolveUserFacing` feeds `isUserFacingRequest` for HTTP
+     * capture. Re-read at each `created`.
+     */
+    internalOrigins?: () => ReadonlyArray<string | null | undefined>;
+}
+export declare class WebSocketTraceSynthesizer {
+    private readonly options;
+    private readonly sockets;
+    private seq;
+    constructor(options: WebSocketSynthesizerOptions);
+    /**
+     * Map one trace event to its CDP message, or null when the event must be
+     * dropped (a non-`created` event for a socketId this synthesizer never saw
+     * created — defensive against out-of-order delivery).
+     */
+    synthesize(sessionId: string, event: NativeWebSocketTrace): SynthesizedWebSocketMessage | null;
+}
+//# sourceMappingURL=websocket.d.ts.map

package/dist/main/services/network-forward/websocket.js

@@ -0,0 +1,120 @@
+/**
+ * Synthesize Chrome DevTools Protocol `Network.webSocket*` messages from the
+ * main-process WebSocket trace stream (see electron-runtime
+ * `native-websocket/trace.ts`).
+ *
+ * Why this exists: `wx.connectSocket` sockets live on the Node `ws` transport
+ * in the MAIN process — no `webContents.debugger` can observe them — so the
+ * embedded DevTools Network tab would never show them. The trace stream gives
+ * one ordered fact per lifecycle moment; this module re-shapes each fact into
+ * the exact CDP event the DevTools front-end already renders natively
+ * (`webSocketCreated` creates the row, handshake events fill it, frames land
+ * in the Messages view, `webSocketClosed` settles it).
+ *
+ * Ordering contract this module relies on (guaranteed by the trace layer):
+ * `created` strictly precedes every other event for its socketId, and exactly
+ * one `closed` terminates each created socket. The front-end silently drops
+ * frame/closed events for an unknown requestId, so this module mirrors that
+ * discipline defensively: any non-created event for an unknown socketId is
+ * dropped rather than synthesized.
+ *
+ * Pure and self-contained (no Electron imports) so it is unit-testable.
+ */
+import { isUserFacingRequest } from './user-facing.js';
+export class WebSocketTraceSynthesizer {
+    options;
+    sockets = new Map();
+    seq = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Map one trace event to its CDP message, or null when the event must be
+     * dropped (a non-`created` event for a socketId this synthesizer never saw
+     * created — defensive against out-of-order delivery).
+     */
+    synthesize(sessionId, event) {
+        const key = `${sessionId} ${event.socketId}`;
+        if (event.type === 'created') {
+            const requestId = `dimina:ws:${this.options.epoch}:${this.seq++}`;
+            const userFacing = isUserFacingRequest(event.url, this.options.internalOrigins?.());
+            this.sockets.set(key, { requestId, userFacing });
+            return {
+                method: 'Network.webSocketCreated',
+                params: { requestId, url: event.url },
+                userFacing,
+            };
+        }
+        const state = this.sockets.get(key);
+        if (!state)
+            return null;
+        const { requestId, userFacing } = state;
+        const timestamp = event.time / 1000;
+        switch (event.type) {
+            case 'handshake-request':
+                return {
+                    method: 'Network.webSocketWillSendHandshakeRequest',
+                    params: {
+                        requestId,
+                        timestamp,
+                        wallTime: timestamp,
+                        request: { headers: event.headers },
+                    },
+                    userFacing,
+                };
+            case 'handshake-response':
+                return {
+                    method: 'Network.webSocketHandshakeResponseReceived',
+                    params: {
+                        requestId,
+                        timestamp,
+                        wallTime: timestamp,
+                        response: {
+                            status: event.status,
+                            statusText: event.statusText,
+                            headers: event.headers,
+                        },
+                    },
+                    userFacing,
+                };
+            case 'frame-sent':
+                return {
+                    method: 'Network.webSocketFrameSent',
+                    params: { requestId, timestamp, response: frame(event, true) },
+                    userFacing,
+                };
+            case 'frame-received':
+                return {
+                    method: 'Network.webSocketFrameReceived',
+                    params: { requestId, timestamp, response: frame(event, false) },
+                    userFacing,
+                };
+            case 'frame-error':
+                return {
+                    method: 'Network.webSocketFrameError',
+                    params: { requestId, timestamp, errorMessage: event.errorMessage },
+                    userFacing,
+                };
+            case 'closed':
+                // Terminal: release the id mapping so a long session can't grow it.
+                this.sockets.delete(key);
+                return {
+                    method: 'Network.webSocketClosed',
+                    params: { requestId, timestamp },
+                    userFacing,
+                };
+        }
+    }
+}
+/** CDP `Network.WebSocketFrame`: client-sent frames are masked, received are not. */
+function frame(event, mask) {
+    const result = {
+        opcode: event.opcode,
+        mask,
+        payloadData: event.payloadData,
+    };
+    if (event.base64Encoded)
+        result.base64Encoded = true;
+    return result;
+}
+//# sourceMappingURL=websocket.js.map

package/dist/main/services/service-host-pool/pool.d.ts

@@ -1,197 +1,2 @@
-import { BrowserWindow } from 'electron';
-/**
- * ServiceHostPool — main-process pre-warm pool for simulator host windows.
- *
- * Design source: `packages/devtools/docs/prewarm-webview.md`. WIRED into
- * native-host via `bridge-router.handleSpawn` (acquire) + `disposeAppSession`
- * (release / releaseDestroyed), opt-in behind `DIMINA_PREWARM_POOL_SIZE`
- * (default OFF). Only the SERVICE-HOST window is pooled; the simulator content
- * WebContentsView (`view-manager.attachNativeSimulator`) is created fresh per
- * attach. (A `<webview>`-tag arch is not poolable — Electron can't reparent a
- * pre-warmed WebContents into a `<webview>`.)
- *
- * Lifecycle of a pool entry:
- *   warming   — BrowserWindow constructed, page loading
- *   ready     — load settled; can be handed to a caller immediately
- *   in-use    — acquired by a caller (caller owns the window until release)
- *   resetting — released; navigated back to a blank page, then storage cleared
- *   disposing — being torn down; removed from the pool
- *
- * ── Phase-3 blockers, both RESOLVED in the wiring (kept here for context) ──
- * 1. Shared-session storage wipe — the service host shares the
- *    `persist:simulator` partition with live projects, so clearing it on reset
- *    would wipe other projects. Resolved by `ServiceHostSpec.clearStorageOnReset`:
- *    `serviceHostSpec()` sets it `false`, so reset only navigates the
- *    window to blank (resetting the JS realm) and never clears the shared
- *    session; cross-spawn isolation rides on appId-namespacing + fresh nav,
- *    matching the already-shared simulator `<webview>` behavior.
- * 2. Warming vs preload contract — warming loads `about:blank` (no bridgeId).
- *    `src/service-host/preload.cjs` now idles (early `return`) when `bridgeId`
- *    is absent instead of throwing, so a warmed window survives until the real
- *    spawn navigation re-runs the preload with a bridgeId.
- *
- * ── Window-death observation ───────────────────────────────────────────────
- * A pooled/in-use window can die three ways: a render crash
- * (`render-process-gone`), a graceful close (`'closed'`), or the owner closing
- * an acquired window (reported via `releaseDestroyed`). All three funnel through
- * `reclaim()`: a POOLED death frees a spare → refill toward target; an IN-USE
- * death is the owner's window → drop the bookkeeping WITHOUT destroying it from
- * under them, and do not refill (the spare count is unaffected).
- */
-/** Entry state machine (see class doc). */
-export type EntryState = 'warming' | 'ready' | 'in-use' | 'resetting' | 'disposing';
-/**
- * A spec fully determines whether a warm window can serve a caller. Reuse is
- * keyed on `preloadPath`: a different preload means a different runtime surface,
- * so the pool will not hand a mismatched entry to a caller.
- *
- * The process-model flags (`contextIsolation` / `sandbox` / `nodeIntegration`)
- * default to the simulator service-host contract (all `false`, mirroring
- * `createServiceHostWindow`) so a warmed window is a faithful stand-in for the
- * window the caller will actually use. They are part of the spec — not
- * hardcoded — so a caller with a different runtime can override them.
- */
-export interface ServiceHostSpec {
-    /** Session partition for the window. Opaque to the pool (see KNOWN BLOCKER 1). */
-    partition: string;
-    /** Absolute path to the preload bundle. The reuse key. */
-    preloadPath: string;
-    /** Initial window size (affects first layout). */
-    size?: {
-        width: number;
-        height: number;
-    };
-    /** Open DevTools on the window (dev only). */
-    devTools?: boolean;
-    /** webPreferences.contextIsolation. Default false (service-host contract). */
-    contextIsolation?: boolean;
-    /** webPreferences.sandbox. Default false (service-host contract). */
-    sandbox?: boolean;
-    /** webPreferences.nodeIntegration. Default false (service-host contract). */
-    nodeIntegration?: boolean;
-    /**
-     * Whether `release` clears this window's session storage. Default `true`.
-     * Set `false` when the window shares a session with live consumers (e.g. the
-     * service host on the shared `persist:simulator` partition) — clearing there
-     * would wipe other projects' storage. With `false`, reset still navigates the
-     * window to a blank page (tearing down the old JS realm); cross-spawn state is
-     * handled by appId-namespacing + the fresh navigation, matching the
-     * already-shared, never-cleared simulator `<webview>` behavior.
-     */
-    clearStorageOnReset?: boolean;
-}
-/** Snapshot of pool occupancy, for dev panels / IPC `prewarm:status`. */
-export interface ServiceHostPoolStats {
-    total: number;
-    ready: number;
-    inUse: number;
-    warming: number;
-    resetting: number;
-    spec: ServiceHostSpec | null;
-}
-export interface ServiceHostPoolInitOptions {
-    /** Number of entries to keep warm. Default target after init. */
-    defaultPoolSize: number;
-    /** Spec used to warm the initial entries. */
-    defaultSpec: ServiceHostSpec;
-    /** Hard ceiling on pooled entries. Clamped to ≤ 4 (see prewarm-webview.md). Default 3. */
-    maxPoolSize?: number;
-}
-export declare class ServiceHostPool {
-    private readonly entries;
-    private currentSpec;
-    private targetSize;
-    private maxPoolSize;
-    private nextId;
-    private disposed;
-    /**
-     * Warm `defaultPoolSize` entries with `defaultSpec`. Normally resolves once the
-     * pool has reached `defaultPoolSize` ready entries — even if a warming window
-     * crashes mid-init and is refilled. NOTE: `warmUpToTarget` caps its refill loop
-     * with a bounded guard, so under SUSTAINED warm crashes `init` resolves
-     * best-effort (possibly under-filled) rather than spinning forever — treat
-     * `getStats().ready` as advisory after init, not a hard invariant.
-     */
-    init(opts: ServiceHostPoolInitOptions): Promise<void>;
-    /**
-     * Hand a ready window matching `spec` to the caller. If none is ready, fall
-     * back to synchronously constructing a fresh window — never blocking on warm
-     * (see prewarm-webview.md's invariants section). Fallback windows carry `entryId === null` and
-     * are destroyed (not pooled) on release.
-     *
-     * A spec change (different `preloadPath`) tears down all *pooled* entries and
-     * re-targets the pool to the new spec; in-use entries are left to their owners
-     * and disposed when returned (see `release`).
-     */
-    acquire(spec: ServiceHostSpec): Promise<{
-        win: BrowserWindow;
-        entryId: string | null;
-    }>;
-    /**
-     * Return a window. Fallback windows (`entryId === null`) and entries whose
-     * spec no longer matches the current pool spec are torn down. Otherwise the
-     * window is reset (navigated to blank, then storage cleared) and re-pooled as
-     * `ready`, unless that would exceed `maxPoolSize`.
-     */
-    release(entryId: string | null, win: BrowserWindow): Promise<void>;
-    /**
-     * The owner of an acquired window reports it died externally (graceful close /
-     * crash) — reclaim its in-use slot so it isn't leaked in `entries` forever
-     * (bridge-router calls this on the `serviceAlreadyClosed` teardown path, where
-     * `release` is intentionally skipped). No-op for an unknown id; idempotent;
-     * never touches the (already-gone) window.
-     */
-    releaseDestroyed(entryId: string | null): void;
-    /**
-     * Re-target the pool. `target` is clamped to `[0, maxPoolSize]`. Pooled
-     * entries beyond the target are disposed OLDEST-FIRST (see prewarm-webview.md); in-use
-     * entries are untouched. Does not warm new entries up (use `init` / refill).
-     */
-    resize(target: number): void;
-    /** Occupancy snapshot. */
-    getStats(): ServiceHostPoolStats;
-    /** Tear down every entry and stop accepting work. */
-    dispose(): Promise<void>;
-    private matches;
-    /** ready + warming + resetting entries are "pooled" (owned by the pool). */
-    private isWarm;
-    private warmCount;
-    private readyCount;
-    /**
-     * Drive the pool to `targetSize` ready entries and resolve only then. Loops so
-     * a crash that drops a warming entry mid-init (which refills asynchronously
-     * via `onGone`) is awaited too, instead of resolving on a stale snapshot. A
-     * generous iteration guard prevents an unbounded spin if windows keep dying.
-     */
-    private warmUpToTarget;
-    private createWindow;
-    private loadBlank;
-    /** Construct + load a fresh pooled entry, registering crash recovery. */
-    private warmOne;
-    /**
-     * Reset a released window back to a clean, blank state. Order matters
-     * (see prewarm-webview.md's state-machine and reset-ordering sections): navigate to blank FIRST so the old document
-     * stops running and in-flight requests are aborted, THEN clear storage — so a
-     * still-live old page cannot re-populate storage after the clear.
-     */
-    private reset;
-    /** A spec change tears down pooled entries and re-targets the pool. */
-    private onSpecChange;
-    /**
-     * Reclaim an entry whose window died externally (render crash, graceful close,
-     * or an owner-reported destruction). A POOLED death frees a spare → refill
-     * toward target; an IN-USE death is the caller's window → drop the bookkeeping
-     * WITHOUT destroying it from under them, and do not refill (the spare count is
-     * unaffected). `destroyIfPooled` destroys the husk for a pooled render crash
-     * (the BrowserWindow object can outlive a dead render process); skip it for a
-     * `'closed'`/owner-reported window that is already gone. No-op if the entry was
-     * already disposed by us (disposeEntry deletes before its own destroy fires
-     * `'closed'`, so this finds nothing).
-     */
-    private reclaim;
-    /** A pooled window's render process died — reclaim + refill (destroy the husk). */
-    private onGone;
-    private disposeEntry;
-    private destroyWindow;
-}
+export * from '@dimina-kit/electron-runtime/main/service-host-pool';
 //# sourceMappingURL=pool.d.ts.map