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

package/dist/main/services/render-inspect/index.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { devtoolsPackageRoot } from '../../utils/paths.js';
+import { createCdpSessionBroker } from '../cdp-session/index.js';
 const DEFAULT_SOURCE_PATH = 'dist/render-host/render-inspect.js';
 /**
  * Chrome DevTools' default Elements-panel highlight palette (content / padding /
@@ -36,13 +37,9 @@ export function createRenderInspector(options = {}) {
         (() => readFileSync(path.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), 'utf8'));
     let cachedSource = null;
     const injected = new Set();
-    // Debugger sessions THIS service attached itself (nobody else owned one). Only
-    // these are detached on guest-destroy; sessions safe-area / Elements-forward
-    // own are never touched (single-owner per wc).
-    const selfAttached = new Set();
-    // Per-wc `DOM.enable → Overlay.enable` handshake, started once and reused so a
-    // burst of hovers shares one enable. Cleared when the guest is destroyed.
-    const enablePromises = new Map();
+    // Shared CDP session broker — owns attach/detach/enable-domain bookkeeping
+    // (see cdp-session/index.ts); this module no longer tracks any of that itself.
+    const broker = options.broker ?? createCdpSessionBroker({ connections: options.connections });
     function source() {
         if (cachedSource === null)
             cachedSource = loadSource();
@@ -71,11 +68,10 @@ export function createRenderInspector(options = {}) {
         }
         injected.add(wc.id);
         // Consolidate the per-wc bookkeeping teardown onto the connection layer
-        // (foundation.md §4 / P2) when a registry is available; fall back to the
+        // (see foundation.md) when a registry is available; fall back to the
         // bespoke `once('destroyed')` only when omitted (focused unit tests).
         const forget = () => {
             injected.delete(wc.id);
-            enablePromises.delete(wc.id);
         };
         if (options.connections) {
             options.connections.acquire(wc).own(forget);
@@ -91,7 +87,7 @@ export function createRenderInspector(options = {}) {
         if (!(await ensureInjected(wc)))
             return null;
         try {
-            const result = (await wc.executeJavaScript('window.__diminaRenderInspect ? window.__diminaRenderInspect.getWxml() : null'));
+            const result = await wc.executeJavaScript('window.__diminaRenderInspect ? window.__diminaRenderInspect.getWxml() : null');
             return result ?? null;
         }
         catch {
@@ -105,7 +101,7 @@ export function createRenderInspector(options = {}) {
             return null;
         let inspection;
         try {
-            const result = (await wc.executeJavaScript(`window.__diminaRenderInspect ? window.__diminaRenderInspect.highlightElement(${JSON.stringify(sid)}) : null`));
+            const result = await wc.executeJavaScript(`window.__diminaRenderInspect ? window.__diminaRenderInspect.highlightElement(${JSON.stringify(sid)}) : null`);
             inspection = result ?? null;
         }
         catch {
@@ -122,16 +118,17 @@ export function createRenderInspector(options = {}) {
     /**
      * Paint the Chrome-style native highlight over the guest via CDP — the same
      * `Overlay.highlightNode` the embedded Elements panel uses, so the WXML panel's
-     * hover box matches it exactly. Reuses the guest's existing debugger session
-     * (single-owner per wc; safe-area / Elements-forward has usually already
-     * attached it) and only attaches itself when nobody has.
+     * hover box matches it exactly. Acquires a lease from the shared broker (see
+     * cdp-session/index.ts), which reuses the guest's existing debugger session
+     * (safe-area / elements-forward has usually already attached it) and only
+     * attaches itself when nobody has.
      *
      * `Overlay.highlightNode` paints only while the Overlay domain is enabled, and
      * Chromium rejects `Overlay.enable` with "DOM should be enabled first" unless
      * DOM is enabled first. On a cold/self-attached session (WXML hovered without
      * the Elements panel ever enabling Overlay) the highlight would silently no-op
-     * if the command raced ahead of the enable, so we AWAIT the `DOM.enable →
-     * Overlay.enable` handshake before highlighting — but only up to
+     * if the command raced ahead of the enable, so we AWAIT the broker's
+     * `ensureRenderDomains()` handshake before highlighting — but only up to
      * `ENABLE_HANDSHAKE_TIMEOUT_MS`, so a hung `DOM.enable` degrades to a missed
      * paint rather than a stuck hover.
      *
@@ -142,22 +139,23 @@ export function createRenderInspector(options = {}) {
     async function drawNativeHighlight(wc, sid) {
         if (wc.isDestroyed())
             return;
-        if (!ensureGuestDebugger(wc))
+        const lease = broker.acquire(wc);
+        if (!lease)
             return;
-        await withTimeout(ensureDomainsEnabled(wc), ENABLE_HANDSHAKE_TIMEOUT_MS);
+        await withTimeout(lease.ensureRenderDomains(), ENABLE_HANDSHAKE_TIMEOUT_MS);
         if (wc.isDestroyed())
             return;
         const expression = `window.__diminaRenderInspect && window.__diminaRenderInspect.elementFor(${JSON.stringify(sid)})`;
         try {
-            const evaluated = (await wc.debugger.sendCommand('Runtime.evaluate', {
+            const evaluated = await lease.send('Runtime.evaluate', {
                 expression,
                 returnByValue: false,
                 objectGroup: HOVER_OBJECT_GROUP,
-            }));
+            });
             const objectId = evaluated?.result?.objectId;
             if (!objectId)
                 return;
-            await wc.debugger.sendCommand('Overlay.highlightNode', {
+            await lease.send('Overlay.highlightNode', {
                 objectId,
                 highlightConfig: HIGHLIGHT_CONFIG,
             });
@@ -165,90 +163,11 @@ export function createRenderInspector(options = {}) {
         finally {
             // Drop the hover's remote DOM reference so repeated hovers don't accumulate
             // live wrappers in the guest context.
-            wc.debugger
-                .sendCommand('Runtime.releaseObjectGroup', { objectGroup: HOVER_OBJECT_GROUP })
+            lease
+                .send('Runtime.releaseObjectGroup', { objectGroup: HOVER_OBJECT_GROUP })
                 .catch(() => { });
         }
     }
-    /**
-     * Ensure the guest's debugger is usable WITHOUT opening a second session: a
-     * webContents debugger is single-owner, so reuse the already-attached session
-     * (Elements-forward / safe-area) and only `attach('1.3')` when nobody has. The
-     * sessions we open ourselves are tracked so guest-destroy detaches only ours.
-     * Returns false when the debugger can't be made usable.
-     */
-    function ensureGuestDebugger(wc) {
-        try {
-            if (wc.debugger.isAttached())
-                return true;
-        }
-        catch {
-            return false;
-        }
-        try {
-            wc.debugger.attach('1.3');
-            trackSelfAttached(wc);
-            return true;
-        }
-        catch {
-            // A concurrent attach (race) leaves it usable; anything else is a failure.
-            try {
-                return wc.debugger.isAttached();
-            }
-            catch {
-                return false;
-            }
-        }
-    }
-    /** Record a self-attached session and detach it when the guest is destroyed. */
-    function trackSelfAttached(wc) {
-        if (selfAttached.has(wc.id))
-            return;
-        selfAttached.add(wc.id);
-        const detach = () => {
-            selfAttached.delete(wc.id);
-            try {
-                if (!wc.isDestroyed() && wc.debugger.isAttached())
-                    wc.debugger.detach();
-            }
-            catch { /* already gone */ }
-        };
-        if (options.connections)
-            options.connections.acquire(wc).own(detach);
-        else {
-            try {
-                wc.once('destroyed', () => selfAttached.delete(wc.id));
-            }
-            catch { /* fake wc */ }
-        }
-    }
-    /**
-     * Enable the DOM + Overlay render domains in dependency order, ONCE per guest
-     * (the promise is cached + reused across hovers). `Overlay.enable` is sent ONLY
-     * AFTER `DOM.enable` resolves (Chromium rejects it otherwise). Resolves when
-     * Overlay is enabled; a rejection at any step is swallowed (the guest may be
-     * mid-teardown) and the cache entry is dropped so a later hover can retry.
-     */
-    function ensureDomainsEnabled(wc) {
-        const cached = enablePromises.get(wc.id);
-        if (cached)
-            return cached;
-        wc.debugger.sendCommand('CSS.enable').catch(() => { });
-        const handshake = wc.debugger
-            .sendCommand('DOM.enable')
-            .then(() => {
-            if (wc.isDestroyed())
-                return;
-            return wc.debugger.sendCommand('Overlay.enable');
-        })
-            .then(() => undefined)
-            .catch(() => {
-            // Allow a retry on the next hover (e.g. the guest was mid-destroy).
-            enablePromises.delete(wc.id);
-        });
-        enablePromises.set(wc.id, handshake);
-        return handshake;
-    }
     async function unhighlight(wc) {
         if (wc.isDestroyed())
             return;

package/dist/main/services/safe-area/index.d.ts

@@ -1,19 +1,34 @@
 import type { WebContents } from 'electron';
 import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { NativeDeviceInfo } from '../../../shared/ipc-channels.js';
+import { type CdpSessionBroker } from '../cdp-session/index.js';
+/** What the guest's own page contributes to the inset policy: whether the
+ *  shell draws a navigation bar over the notch for it. */
+export interface GuestPageInsetPolicy {
+    isCustomNav: boolean;
+}
+/**
+ * Read a guest's inset policy off its render-host URL (`navStyle`, written by
+ * `buildRenderHostDocumentUrl`). An unparseable URL degrades to the default-nav
+ * policy rather than failing the attach.
+ */
+export declare function parseGuestPageInsetPolicy(src: string): GuestPageInsetPolicy;
 export interface SafeAreaController {
     /** Attach the debugger to a freshly-attached render-host guest and push the
-     *  current device's insets. `isTabPage` selects the bottom-inset policy (0 for
-     *  tab pages, the real inset for full-bleed non-tab pages). No-op (warn) if the
-     *  guest is already claimed by an external CDP client — env then stays 0. */
-    applyToGuest(guestWc: WebContents, device: NativeDeviceInfo | null, isTabPage: boolean): void;
+     *  current device's insets. `page` selects the top policy (real inset only for
+     *  a custom-nav page); the bottom inset always comes from the device. No-op
+     *  (warn) if the guest is already claimed by an external CDP client — env
+     *  then stays 0. */
+    applyToGuest(guestWc: WebContents, device: NativeDeviceInfo | null, page: GuestPageInsetPolicy): void;
     /** Re-push insets to every still-attached guest after a device change (each
-     *  guest keeps the page type it attached with). */
+     *  guest keeps the page policy it attached with). */
     reapplyAll(device: NativeDeviceInfo | null): void;
-    /** Detach from all guests (teardown). */
+    /** Release this controller's session leases (teardown). Does not itself
+     *  detach the shared debugger session — see cdp-session/index.ts. */
     dispose(): void;
 }
 export declare function createSafeAreaController(options?: {
     connections?: ConnectionRegistry;
+    broker?: CdpSessionBroker;
 }): SafeAreaController;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/safe-area/index.js

@@ -1,64 +1,110 @@
-function guestInsets(device, isTabPage) {
-    const top = device?.safeAreaInsets.top ?? 0;
-    // A tab page's content sits above the shell-drawn tabBar (which fills the
-    // bottom safe area), so it never borders the bottom unsafe zone. A non-tab
-    // page is full-bleed to the device bottom, so surface the real inset for its
-    // own `env(safe-area-inset-bottom)` opt-in.
-    const bottom = isTabPage ? 0 : (device?.safeAreaInsets.bottom ?? 0);
-    return { top, topMax: top, right: 0, rightMax: 0, bottom, bottomMax: bottom, left: 0, leftMax: 0 };
+import { createCdpSessionBroker } from '../cdp-session/index.js';
+/**
+ * Read a guest's inset policy off its render-host URL (`navStyle`, written by
+ * `buildRenderHostDocumentUrl`). An unparseable URL degrades to the default-nav
+ * policy rather than failing the attach.
+ */
+export function parseGuestPageInsetPolicy(src) {
+    try {
+        const params = new URL(src).searchParams;
+        return { isCustomNav: params.get('navStyle') === 'custom' };
+    }
+    catch {
+        return { isCustomNav: false };
+    }
+}
+function guestInsets(device, page) {
+    // Only a custom-nav (full-bleed) page borders the unsafe top zone; a
+    // default-nav page already starts below the shell nav bar, which covers the
+    // notch itself.
+    const top = page.isCustomNav ? (device?.safeAreaInsets.top ?? 0) : 0;
+    const bottom = device?.safeAreaInsets.bottom ?? 0;
+    // Left/right come straight from the device (e.g. a landscape Dynamic Island
+    // rotates into a side notch) — unlike top they don't depend on page
+    // type, since neither shell chrome nor the tabBar reserves horizontal space.
+    const right = device?.safeAreaInsets.right ?? 0;
+    const left = device?.safeAreaInsets.left ?? 0;
+    return { top, topMax: top, right, rightMax: right, bottom, bottomMax: bottom, left, leftMax: left };
 }
 export function createSafeAreaController(options = {}) {
-    // Guests we successfully attached `wc.debugger` to (value = the page's
-    // `isTabPage`, fixed for the guest's life — it's one page). So we don't
-    // re-attach (throws), and a device-change reapply reuses the same policy.
-    const attached = new Map();
-    function override(wc, device, isTabPage) {
+    // Own (and dispose on this controller's own dispose()) a private broker
+    // only when the caller didn't supply a shared one.
+    const ownsBroker = !options.broker;
+    // The shared CDP session broker (see cdp-session/index.ts) — reused across
+    // safe-area/elements-forward/render-inspect/network-forward when the caller
+    // passes one; falls back to a private instance so this module stays
+    // independently testable/usable.
+    const broker = options.broker ?? createCdpSessionBroker({ connections: options.connections });
+    // Each guest's page policy, fixed for its life — tracked SEPARATELY from the
+    // lease so a lost session (external detach) doesn't lose the policy: a
+    // later `override`/`reapplyAll` can reacquire and keep applying the same
+    // policy this guest attached with.
+    const pageType = new Map();
+    // Current lease per guest, if any. Cleared (not just left stale) on
+    // `lease.onDetach` — an external detach or a real Chrome DevTools window
+    // stealing the session — so the next `override` reacquires instead of
+    // sending through a dead lease forever.
+    const leases = new Map();
+    /** Get-or-reacquire this guest's lease. Null when the session is unavailable. */
+    function ensureLease(wc) {
+        const existing = leases.get(wc);
+        if (existing)
+            return existing;
+        const lease = broker.acquire(wc);
+        if (!lease)
+            return null;
+        leases.set(wc, lease);
+        lease.onDetach(() => { leases.delete(wc); });
+        return lease;
+    }
+    function override(wc, device, page) {
         if (wc.isDestroyed())
             return;
-        void wc.debugger
-            .sendCommand('Emulation.setSafeAreaInsetsOverride', { insets: guestInsets(device, isTabPage) })
+        const lease = ensureLease(wc);
+        if (!lease) {
+            // Exclusively held elsewhere (e.g. a real Chrome DevTools window via
+            // --remote-debugging-port). Degrade: leave env at 0 rather than fail
+            // the page.
+            console.warn('[safe-area] debugger session unavailable; env(safe-area-inset-*) stays 0');
+            return;
+        }
+        void lease
+            .send('Emulation.setSafeAreaInsetsOverride', { insets: guestInsets(device, page) })
             .catch((err) => {
             console.warn('[safe-area] setSafeAreaInsetsOverride failed:', err instanceof Error ? err.message : err);
         });
     }
     return {
-        applyToGuest: (wc, device, isTabPage) => {
-            if (!wc || wc.isDestroyed() || attached.has(wc)) {
-                if (wc && !wc.isDestroyed() && attached.has(wc))
-                    override(wc, device, isTabPage);
-                return;
-            }
-            try {
-                wc.debugger.attach('1.3');
-            }
-            catch (err) {
-                // Already attached by an external --remote-debugging-port client (or
-                // DevTools). Degrade: leave env at 0 rather than fail the page.
-                console.warn('[safe-area] debugger.attach failed; env(safe-area-inset-*) stays 0:', err instanceof Error ? err.message : err);
+        applyToGuest: (wc, device, page) => {
+            if (!wc || wc.isDestroyed())
                 return;
+            const isFirstTime = !pageType.has(wc);
+            pageType.set(wc, page);
+            if (isFirstTime) {
+                const forget = () => { pageType.delete(wc); leases.delete(wc); };
+                if (options.connections) {
+                    options.connections.acquire(wc).own(forget);
+                }
+                else {
+                    wc.once('destroyed', forget);
+                }
             }
-            attached.set(wc, isTabPage);
-            if (options.connections) {
-                options.connections.acquire(wc).own(() => attached.delete(wc));
-            }
-            else {
-                wc.once('destroyed', () => attached.delete(wc));
-            }
-            override(wc, device, isTabPage);
+            override(wc, device, page);
         },
         reapplyAll: (device) => {
-            for (const [wc, isTabPage] of attached)
-                override(wc, device, isTabPage);
+            for (const [wc, page] of pageType)
+                override(wc, device, page);
         },
         dispose: () => {
-            for (const wc of attached.keys()) {
-                try {
-                    if (!wc.isDestroyed())
-                        wc.debugger.detach();
-                }
-                catch { /* already detached / destroyed */ }
-            }
-            attached.clear();
+            // Release our leases only — the shared session's actual detach is the
+            // broker's own top-level dispose() to decide (another consumer may
+            // still be using it).
+            for (const lease of leases.values())
+                lease.dispose();
+            leases.clear();
+            pageType.clear();
+            if (ownsBroker)
+                broker.dispose();
         },
     };
 }

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 (doc §3.3). 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
-     * (doc §3.1 "绝不阻塞 acquire"). 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 (doc §3.3/§3.6); 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
-     * (doc §3.5.3 / §3.4「等待时序」): 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