@dimina-kit/devtools 0.4.0-dev.20260728110120 → 0.4.0-dev.20260731100034

package/dist/main/services/service-host-pool/pool.js

@@ -1,364 +1,2 @@
-import { BrowserWindow } from 'electron';
-/** Blank placeholder URL loaded while warming / after reset. */
-const BLANK_URL = 'about:blank';
-/** Hard ceiling on pool size regardless of requested size (see prewarm-webview.md). */
-const HARD_MAX_POOL_SIZE = 4;
-/** Storage buckets cleared on every release (see prewarm-webview.md's reset checklist). */
-const RESET_STORAGES = [
-    'cookies',
-    'localstorage',
-    'indexdb',
-    'serviceworkers',
-    'cachestorage',
-];
-export class ServiceHostPool {
-    entries = new Map();
-    currentSpec = null;
-    targetSize = 0;
-    maxPoolSize = 3;
-    nextId = 0;
-    disposed = false;
-    /**
-     * 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.
-     */
-    async init(opts) {
-        if (this.disposed)
-            return;
-        this.currentSpec = opts.defaultSpec;
-        this.maxPoolSize = Math.min(opts.maxPoolSize ?? 3, HARD_MAX_POOL_SIZE);
-        this.targetSize = Math.min(Math.max(opts.defaultPoolSize, 0), this.maxPoolSize);
-        await this.warmUpToTarget();
-    }
-    /**
-     * 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`).
-     */
-    async acquire(spec) {
-        if (this.currentSpec && this.currentSpec.preloadPath !== spec.preloadPath) {
-            this.onSpecChange(spec);
-        }
-        else if (!this.currentSpec) {
-            this.currentSpec = spec;
-        }
-        for (const entry of this.entries.values()) {
-            if (entry.state === 'ready' && this.matches(entry.spec, spec)) {
-                // A ready entry whose window died (closed/crashed) while idle must never
-                // be handed out — navigating a destroyed WebContents silently no-ops the
-                // spawn. Drop it (and refill) and keep scanning.
-                if (entry.win.isDestroyed()) {
-                    this.reclaim(entry, { destroyIfPooled: false, refill: false });
-                    continue;
-                }
-                entry.state = 'in-use';
-                return { win: entry.win, entryId: entry.id };
-            }
-        }
-        // Pool miss → fallback create. Not pooled; entryId null.
-        const win = this.createWindow(spec);
-        // Kick the load but do not await — acquire must not block.
-        void this.loadBlank(win);
-        return { win, entryId: 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`.
-     */
-    async release(entryId, win) {
-        if (entryId === null) {
-            this.destroyWindow(win);
-            return;
-        }
-        const entry = this.entries.get(entryId);
-        if (!entry) {
-            this.destroyWindow(win);
-            return;
-        }
-        if (this.disposed || !this.currentSpec || !this.matches(entry.spec, this.currentSpec)) {
-            this.disposeEntry(entry);
-            return;
-        }
-        entry.state = 'resetting';
-        await this.reset(entry);
-        // The entry may have been disposed/crashed/spec-changed/destroyed underneath
-        // the reset await; only re-pool if it is still the live, resetting entry with
-        // a live window. A destroyed window must never be re-marked `ready` (a later
-        // acquire would hand it out and the spawn would silently never boot).
-        if (this.disposed
-            || this.entries.get(entryId) !== entry
-            || entry.state !== 'resetting'
-            || entry.win.isDestroyed()) {
-            this.destroyWindow(entry.win);
-            this.entries.delete(entryId);
-            return;
-        }
-        // Honor the hard cap: if re-pooling would exceed maxPoolSize, drop it.
-        const otherPooled = this.warmCount() - (this.isWarm(entry) ? 1 : 0);
-        if (otherPooled >= this.maxPoolSize) {
-            this.disposeEntry(entry);
-            return;
-        }
-        entry.state = 'ready';
-    }
-    /**
-     * 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) {
-        if (entryId === null)
-            return;
-        const entry = this.entries.get(entryId);
-        if (!entry)
-            return;
-        this.reclaim(entry, { destroyIfPooled: false, refill: false });
-    }
-    /**
-     * 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) {
-        this.targetSize = Math.min(Math.max(target, 0), this.maxPoolSize);
-        // Map iteration is insertion order, so `pooled` is oldest-first. Dispose the
-        // oldest prefix and keep the `targetSize` most-recently-created entries.
-        const pooled = [...this.entries.values()].filter((e) => this.isWarm(e));
-        const surplus = pooled.length - this.targetSize;
-        if (surplus <= 0)
-            return;
-        for (const entry of pooled.slice(0, surplus)) {
-            this.disposeEntry(entry);
-        }
-    }
-    /** Occupancy snapshot. */
-    getStats() {
-        let ready = 0;
-        let inUse = 0;
-        let warming = 0;
-        let resetting = 0;
-        for (const entry of this.entries.values()) {
-            switch (entry.state) {
-                case 'ready':
-                    ready++;
-                    break;
-                case 'in-use':
-                    inUse++;
-                    break;
-                case 'warming':
-                    warming++;
-                    break;
-                case 'resetting':
-                    resetting++;
-                    break;
-            }
-        }
-        return { total: this.entries.size, ready, inUse, warming, resetting, spec: this.currentSpec };
-    }
-    /** Tear down every entry and stop accepting work. */
-    async dispose() {
-        this.disposed = true;
-        this.targetSize = 0;
-        for (const entry of [...this.entries.values()]) {
-            this.disposeEntry(entry);
-        }
-    }
-    // ── internals ──────────────────────────────────────────────────────────
-    matches(a, b) {
-        return a.preloadPath === b.preloadPath;
-    }
-    /** ready + warming + resetting entries are "pooled" (owned by the pool). */
-    isWarm(entry) {
-        return entry.state === 'ready' || entry.state === 'warming' || entry.state === 'resetting';
-    }
-    warmCount() {
-        let n = 0;
-        for (const entry of this.entries.values()) {
-            if (this.isWarm(entry))
-                n++;
-        }
-        return n;
-    }
-    readyCount() {
-        let n = 0;
-        for (const entry of this.entries.values()) {
-            if (entry.state === 'ready')
-                n++;
-        }
-        return n;
-    }
-    /**
-     * 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.
-     */
-    async warmUpToTarget() {
-        if (!this.currentSpec)
-            return;
-        let guard = 0;
-        const maxIterations = this.targetSize * 8 + 8;
-        while (!this.disposed && this.readyCount() < this.targetSize && guard++ < maxIterations) {
-            while (this.warmCount() < this.targetSize) {
-                void this.warmOne(this.currentSpec);
-            }
-            const warming = [...this.entries.values()]
-                .filter((e) => e.state === 'warming')
-                .map((e) => e.ready);
-            if (warming.length === 0)
-                break;
-            await Promise.all(warming);
-        }
-    }
-    createWindow(spec) {
-        return new BrowserWindow({
-            show: false,
-            width: spec.size?.width,
-            height: spec.size?.height,
-            webPreferences: {
-                preload: spec.preloadPath,
-                partition: spec.partition,
-                // Mirror createServiceHostWindow's process model (create.ts:24-30): the
-                // service-host preload does `require('electron')` and writes globals
-                // onto the page realm, so it requires nodeIntegration:false,
-                // contextIsolation:false, sandbox:false. Default to that contract; let a
-                // caller override via the spec for a different runtime.
-                nodeIntegration: spec.nodeIntegration ?? false,
-                contextIsolation: spec.contextIsolation ?? false,
-                sandbox: spec.sandbox ?? false,
-            },
-        });
-    }
-    loadBlank(win) {
-        // `loadURL` resolves on did-finish-load in Electron; treat any failure as a
-        // settled load so a single bad warm never wedges the pool. The synchronous
-        // call ITSELF throws on an already-destroyed webContents (it isn't a
-        // rejection) — swallow that too, so reset/release of a window that died
-        // mid-flight resolves instead of rejecting (the "never wedges" contract).
-        try {
-            return Promise.resolve(win.webContents.loadURL(BLANK_URL)).then(() => undefined, () => undefined);
-        }
-        catch {
-            return Promise.resolve();
-        }
-    }
-    /** Construct + load a fresh pooled entry, registering crash recovery. */
-    warmOne(spec) {
-        const win = this.createWindow(spec);
-        const id = `pool-${++this.nextId}`;
-        const entry = { id, spec, state: 'warming', win, ready: Promise.resolve() };
-        this.entries.set(id, entry);
-        win.webContents.on('render-process-gone', () => this.onGone(entry));
-        // A window can also die by graceful close (app quit / manual close), which
-        // never fires render-process-gone. Observe it too so a pooled entry isn't
-        // leaked. reclaim is a no-op if WE disposed it (disposeEntry deletes the
-        // entry before its own destroy fires 'closed').
-        win.once('closed', () => this.reclaim(entry, { destroyIfPooled: false, refill: false }));
-        entry.ready = this.loadBlank(win).then(() => {
-            if (entry.state === 'warming')
-                entry.state = 'ready';
-        });
-        return entry.ready;
-    }
-    /**
-     * 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.
-     */
-    async reset(entry) {
-        await this.loadBlank(entry.win);
-        // Consumers sharing a session opt out of the storage clear (see
-        // ServiceHostSpec.clearStorageOnReset): clearing a shared partition would wipe
-        // other live projects. Navigation-to-blank above still resets the JS realm.
-        if (entry.spec.clearStorageOnReset === false)
-            return;
-        // The window may have been destroyed during the load await; touching a dead
-        // webContents.session throws SYNCHRONOUSLY, which would reject release().
-        if (entry.win.isDestroyed())
-            return;
-        try {
-            const ses = entry.win.webContents.session;
-            await ses.clearStorageData({ storages: [...RESET_STORAGES] });
-            await ses.clearCache();
-        }
-        catch {
-            // Window/session torn down mid-reset — release() re-checks isDestroyed and
-            // disposes the entry, so swallowing here keeps release from rejecting.
-        }
-    }
-    /** A spec change tears down pooled entries and re-targets the pool. */
-    onSpecChange(spec) {
-        for (const entry of [...this.entries.values()]) {
-            if (this.isWarm(entry))
-                this.disposeEntry(entry);
-        }
-        this.currentSpec = spec;
-    }
-    /**
-     * 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).
-     */
-    reclaim(entry, opts) {
-        if (!this.entries.has(entry.id))
-            return;
-        const wasPooled = this.isWarm(entry);
-        entry.state = 'disposing';
-        this.entries.delete(entry.id);
-        if (wasPooled && opts.destroyIfPooled)
-            this.destroyWindow(entry.win);
-        // Refill ONLY on crash recovery (onGone). A graceful `'closed'` on a pooled
-        // window happens exclusively at app/project teardown (the windows are hidden;
-        // nothing else closes them) — refilling there would `new BrowserWindow` while
-        // Electron is trying to quit, recreating windows faster than they close and
-        // hanging the shutdown. So `refill` is opt-in per caller.
-        if (!opts.refill || this.disposed || !this.currentSpec || !wasPooled)
-            return;
-        while (this.warmCount() < this.targetSize) {
-            void this.warmOne(this.currentSpec);
-        }
-    }
-    /** A pooled window's render process died — reclaim + refill (destroy the husk). */
-    onGone(entry) {
-        this.reclaim(entry, { destroyIfPooled: true, refill: true });
-    }
-    disposeEntry(entry) {
-        entry.state = 'disposing';
-        this.entries.delete(entry.id);
-        this.destroyWindow(entry.win);
-    }
-    destroyWindow(win) {
-        try {
-            if (!win || (typeof win.isDestroyed === 'function' && win.isDestroyed()))
-                return;
-            if (typeof win.destroy === 'function')
-                win.destroy();
-            else if (typeof win.close === 'function')
-                win.close();
-        }
-        catch {
-            // A window already gone (e.g. crashed process) is fine to ignore.
-        }
-    }
-}
+export * from '@dimina-kit/electron-runtime/main/service-host-pool';
 //# sourceMappingURL=pool.js.map

package/dist/main/services/simulator/custom-apis.d.ts

@@ -1,43 +1,2 @@
-export type SimulatorApiHandler = (params: unknown) => unknown | Promise<unknown>;
-export interface SimulatorApiRegistry {
-    register(name: string, handler: SimulatorApiHandler): () => void;
-    list(): string[];
-    has(name: string): boolean;
-    invoke(name: string, params: unknown): Promise<unknown>;
-    clear(): void;
-}
-/**
- * Bridge request/response shapes shared by the simulator-side preload
- * (`src/preload/runtime/custom-apis.ts`) and the two host-side dispatchers that
- * service it (the trusted main-window renderer proxy was the original path; the
- * native-host top-level WebContentsView dispatcher in the ViewManager is the
- * current one). Kept here next to the registry so both stay in lockstep with
- * the preload contract.
- */
-export type CustomApiBridgeRequest = {
-    id: number;
-    op: 'list';
-} | {
-    id: number;
-    op: 'invoke';
-    name: string;
-    params: unknown;
-};
-export type CustomApiBridgeResponse = {
-    id: number;
-    result: unknown;
-} | {
-    id: number;
-    error: string;
-};
-/**
- * Run a single custom-apis bridge request against the given registry and return
- * the id-correlated response the preload's pending-map expects. Never throws:
- * a handler rejection / malformed request becomes an `{ id, error }` response so
- * the caller only has to ship it back over the bridge channel. The one shared
- * implementation behind both the `SimulatorCustomApiChannel` IPC handlers and
- * the native-host `ipc-message-host` dispatcher.
- */
-export declare function handleCustomApiBridgeRequest(apis: Pick<SimulatorApiRegistry, 'list' | 'invoke'>, req: CustomApiBridgeRequest): Promise<CustomApiBridgeResponse>;
-export declare function createSimulatorApiRegistry(): SimulatorApiRegistry;
+export * from '@dimina-kit/electron-runtime/main/custom-apis';
 //# sourceMappingURL=custom-apis.d.ts.map

package/dist/main/services/simulator/custom-apis.js

@@ -1,47 +1,2 @@
-/**
- * Run a single custom-apis bridge request against the given registry and return
- * the id-correlated response the preload's pending-map expects. Never throws:
- * a handler rejection / malformed request becomes an `{ id, error }` response so
- * the caller only has to ship it back over the bridge channel. The one shared
- * implementation behind both the `SimulatorCustomApiChannel` IPC handlers and
- * the native-host `ipc-message-host` dispatcher.
- */
-export async function handleCustomApiBridgeRequest(apis, req) {
-    try {
-        const result = req.op === 'list'
-            ? apis.list()
-            : await apis.invoke(req.name, req.params);
-        return { id: req.id, result };
-    }
-    catch (err) {
-        return { id: req.id, error: err instanceof Error ? err.message : String(err) };
-    }
-}
-export function createSimulatorApiRegistry() {
-    const handlers = new Map();
-    return {
-        register(name, handler) {
-            handlers.set(name, handler);
-            return () => {
-                if (handlers.get(name) === handler)
-                    handlers.delete(name);
-            };
-        },
-        list() {
-            return Array.from(handlers.keys());
-        },
-        has(name) {
-            return handlers.has(name);
-        },
-        async invoke(name, params) {
-            const handler = handlers.get(name);
-            if (!handler)
-                throw new Error(`Simulator API "${name}" is not registered`);
-            return await handler(params);
-        },
-        clear() {
-            handlers.clear();
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/custom-apis';
 //# sourceMappingURL=custom-apis.js.map

package/dist/main/services/simulator/referer.d.ts

@@ -1,10 +1,2 @@
-/**
- * WeChat-style page-frame referer for HTTPS requests proxied from the simulator session.
- * Format: https://servicewechat.com/{appId}/{version}/page-frame.html
- */
-export declare function buildServicewechatPageFrameReferer(appId: string, version?: string): string;
-/** Called when a project session is active so protocol.handle can force Referer. */
-export declare function setSimulatorServicewechatReferer(appId: string, version?: string): void;
-export declare function clearSimulatorServicewechatReferer(): void;
-export declare function getSimulatorServicewechatReferer(): string | null;
+export * from '@dimina-kit/electron-runtime/main/referer';
 //# sourceMappingURL=referer.d.ts.map

package/dist/main/services/simulator/referer.js

@@ -1,20 +1,2 @@
-/**
- * WeChat-style page-frame referer for HTTPS requests proxied from the simulator session.
- * Format: https://servicewechat.com/{appId}/{version}/page-frame.html
- */
-const DEFAULT_VERSION = 'develop';
-let cachedRefererUrl = null;
-export function buildServicewechatPageFrameReferer(appId, version = DEFAULT_VERSION) {
-    return `https://servicewechat.com/${appId}/${version}/page-frame.html`;
-}
-/** Called when a project session is active so protocol.handle can force Referer. */
-export function setSimulatorServicewechatReferer(appId, version) {
-    cachedRefererUrl = buildServicewechatPageFrameReferer(appId, version && version.length > 0 ? version : DEFAULT_VERSION);
-}
-export function clearSimulatorServicewechatReferer() {
-    cachedRefererUrl = null;
-}
-export function getSimulatorServicewechatReferer() {
-    return cachedRefererUrl;
-}
+export * from '@dimina-kit/electron-runtime/main/referer';
 //# sourceMappingURL=referer.js.map

package/dist/main/services/simulator/ui-extensions.d.ts

@@ -0,0 +1,13 @@
+import type { WebContents } from 'electron';
+import type { SimulatorUiExtensionHandle, SimulatorUiExtensionRegistration } from '../../../shared/simulator-ui.js';
+export interface SimulatorUiExtensionRegistry {
+    register(registration: SimulatorUiExtensionRegistration): SimulatorUiExtensionHandle;
+    attach(webContents: WebContents): void;
+    detach(webContents?: WebContents): void;
+    clear(): void;
+}
+export interface SimulatorUiExtensionRegistryOptions {
+    loadSource?: (scriptPath: string) => Promise<string>;
+}
+export declare function createSimulatorUiExtensionRegistry(options?: SimulatorUiExtensionRegistryOptions): SimulatorUiExtensionRegistry;
+//# sourceMappingURL=ui-extensions.d.ts.map

package/dist/main/services/simulator/ui-extensions.js

@@ -0,0 +1,166 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const EXTENSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function createSimulatorUiExtensionRegistry(options = {}) {
+    const loadSource = options.loadSource ?? (scriptPath => readFile(scriptPath, 'utf8'));
+    const entries = new Map();
+    let active = null;
+    function assertRegistration(registration) {
+        if (!EXTENSION_ID_RE.test(registration.id)) {
+            throw new Error(`Invalid simulator UI extension id: "${registration.id}"`);
+        }
+        if (!isAbsolute(registration.rendererScriptPath)) {
+            throw new Error('Simulator UI extension rendererScriptPath must be absolute');
+        }
+        if (entries.has(registration.id)) {
+            throw new Error(`Simulator UI extension "${registration.id}" is already registered`);
+        }
+    }
+    function activeExpression(method, args) {
+        return `globalThis.__diminaSimulatorUi.${method}(${args.map(arg => JSON.stringify(arg)).join(',')})`;
+    }
+    async function install(entry, target) {
+        const { id, rendererScriptPath } = entry.registration;
+        if (target.loaded.has(id))
+            return;
+        const pending = target.loading.get(id);
+        if (pending)
+            return await pending;
+        const generation = target.generation;
+        const task = (async () => {
+            // Read once per simulator document generation so downstream watch builds
+            // become visible after a hard reload without restarting the workbench.
+            const source = await loadSource(rendererScriptPath);
+            if (entries.get(id) !== entry
+                ||
+                    active !== target
+                || target.webContents.isDestroyed()
+                || !target.ready
+                || target.generation !== generation) {
+                throw new Error('Simulator UI extension target is no longer available');
+            }
+            const sourceUrl = pathToFileURL(rendererScriptPath).href;
+            const wrapped = `(()=>{\n${source}\n;return undefined\n})()\n//# sourceURL=${sourceUrl}`;
+            await target.webContents.executeJavaScript(wrapped, true);
+            if (entries.get(id) !== entry
+                ||
+                    active !== target
+                || target.webContents.isDestroyed()
+                || !target.ready
+                || target.generation !== generation) {
+                throw new Error('Simulator UI extension target was destroyed during installation');
+            }
+            const registered = await target.webContents.executeJavaScript(`Boolean(globalThis.__diminaSimulatorUi?.has(${JSON.stringify(id)}))`, true);
+            if (!registered) {
+                throw new Error(`Simulator UI extension "${id}" did not register its renderer implementation`);
+            }
+            target.loaded.add(id);
+        })().finally(() => {
+            if (target.loading.get(id) === task)
+                target.loading.delete(id);
+        });
+        target.loading.set(id, task);
+        return await task;
+    }
+    async function installAll(target) {
+        for (const entry of entries.values()) {
+            try {
+                await install(entry, target);
+            }
+            catch (error) {
+                console.warn(`[simulator-ui] failed to install "${entry.registration.id}":`, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    function uninstall(id, target = active) {
+        if (!target)
+            return;
+        target.loaded.delete(id);
+        target.loading.delete(id);
+        if (!target.ready || target.webContents.isDestroyed())
+            return;
+        void target.webContents.executeJavaScript(`globalThis.__diminaSimulatorUi?.unregister(${JSON.stringify(id)})`, true).catch(() => { });
+    }
+    function detach(webContents) {
+        const target = active;
+        if (!target || (webContents && target.webContents !== webContents))
+            return;
+        active = null;
+        if (!target.webContents.isDestroyed()) {
+            target.webContents.removeListener('did-finish-load', target.onLoaded);
+        }
+        target.loaded.clear();
+        target.loading.clear();
+    }
+    function attach(webContents) {
+        detach();
+        const target = {
+            webContents,
+            ready: false,
+            generation: 0,
+            loaded: new Set(),
+            loading: new Map(),
+            onLoaded: () => { },
+        };
+        target.onLoaded = () => {
+            if (active !== target || webContents.isDestroyed())
+                return;
+            target.ready = true;
+            target.generation += 1;
+            target.loaded.clear();
+            target.loading.clear();
+            void installAll(target);
+        };
+        active = target;
+        webContents.on('did-finish-load', target.onLoaded);
+    }
+    function register(registration) {
+        assertRegistration(registration);
+        const stableRegistration = { ...registration };
+        const entry = {
+            registration: stableRegistration,
+        };
+        entries.set(stableRegistration.id, entry);
+        const target = active;
+        if (target?.ready) {
+            void install(entry, target).catch((error) => {
+                console.warn(`[simulator-ui] failed to install "${stableRegistration.id}":`, error instanceof Error ? error.message : String(error));
+            });
+        }
+        let disposed = false;
+        return {
+            dispose() {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (entries.get(stableRegistration.id) !== entry)
+                    return;
+                entries.delete(stableRegistration.id);
+                uninstall(stableRegistration.id);
+            },
+            async invoke(method, params) {
+                if (disposed || entries.get(stableRegistration.id) !== entry) {
+                    throw new Error(`Simulator UI extension "${stableRegistration.id}" is disposed`);
+                }
+                const current = active;
+                if (!current || current.webContents.isDestroyed() || !current.ready) {
+                    throw new Error('Dimina simulator UI is not ready');
+                }
+                await install(entry, current);
+                if (active !== current || current.webContents.isDestroyed()) {
+                    throw new Error('Dimina simulator UI was replaced during invocation');
+                }
+                return await current.webContents.executeJavaScript(activeExpression('invoke', [stableRegistration.id, method, params ?? null]), true);
+            },
+        };
+    }
+    function clear() {
+        for (const id of entries.keys())
+            uninstall(id);
+        entries.clear();
+        detach();
+    }
+    return { register, attach, detach, clear };
+}
+//# sourceMappingURL=ui-extensions.js.map