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

package/dist/main/ipc/app-lifecycle.d.ts

@@ -1,32 +1,2 @@
-/**
- * Per-app-session registry for the app-level lifecycle listeners registered
- * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
- * (and their `off*` removers).
- *
- * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
- * persistent callback id in `params.success` (service `callback.store(fn,
- * keep=true)`), so the router stores the id here and re-fires it via
- * `sendCallback` on every app foreground / background / error.
- *
- * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
- * `callback.store` dedups by function and returns the original evtId, so `off*`
- * carries that id and removes exactly that listener. `wx.offAppShow()` with no
- * argument carries no id and clears every listener of the event (WeChat
- * contract).
- */
-export type AppLifecycleEvent = 'onAppShow' | 'onAppHide' | 'onError';
-export interface AppLifecycleController {
-    /** Store a keep callback id for an event. Null/undefined ids are ignored. */
-    register(appSessionId: string, event: AppLifecycleEvent, callbackId: unknown): void;
-    /**
-     * Remove a listener. With `callbackId`, removes only that id; without one,
-     * clears every listener of the event for the session.
-     */
-    unregister(appSessionId: string, event: AppLifecycleEvent, callbackId?: unknown): void;
-    /** Snapshot of the registered callback ids (empty for unknown session/event). */
-    listeners(appSessionId: string, event: AppLifecycleEvent): unknown[];
-    /** Drop all listeners for a torn-down session. */
-    dispose(appSessionId: string): void;
-}
-export declare function createAppLifecycleController(): AppLifecycleController;
+export * from '@dimina-kit/electron-runtime/main/app-lifecycle';
 //# sourceMappingURL=app-lifecycle.d.ts.map

package/dist/main/ipc/app-lifecycle.js

@@ -1,54 +1,2 @@
-/**
- * Per-app-session registry for the app-level lifecycle listeners registered
- * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
- * (and their `off*` removers).
- *
- * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
- * persistent callback id in `params.success` (service `callback.store(fn,
- * keep=true)`), so the router stores the id here and re-fires it via
- * `sendCallback` on every app foreground / background / error.
- *
- * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
- * `callback.store` dedups by function and returns the original evtId, so `off*`
- * carries that id and removes exactly that listener. `wx.offAppShow()` with no
- * argument carries no id and clears every listener of the event (WeChat
- * contract).
- */
-export function createAppLifecycleController() {
-    const sessions = new Map();
-    return {
-        register(appSessionId, event, callbackId) {
-            if (callbackId === undefined || callbackId === null)
-                return;
-            let events = sessions.get(appSessionId);
-            if (!events) {
-                events = new Map();
-                sessions.set(appSessionId, events);
-            }
-            let ids = events.get(event);
-            if (!ids) {
-                ids = new Set();
-                events.set(event, ids);
-            }
-            ids.add(callbackId);
-        },
-        unregister(appSessionId, event, callbackId) {
-            const events = sessions.get(appSessionId);
-            if (!events)
-                return;
-            if (callbackId === undefined || callbackId === null) {
-                events.delete(event);
-                return;
-            }
-            events.get(event)?.delete(callbackId);
-        },
-        listeners(appSessionId, event) {
-            const ids = sessions.get(appSessionId)?.get(event);
-            return ids ? Array.from(ids) : [];
-        },
-        dispose(appSessionId) {
-            sessions.delete(appSessionId);
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/app-lifecycle';
 //# sourceMappingURL=app-lifecycle.js.map

package/dist/main/ipc/bridge-router.d.ts

@@ -1,155 +1,22 @@
-import type { WebContents } from 'electron';
-import type { NativeDeviceInfo } from '../../shared/ipc-channels.js';
-import type { PageStackEntry } from '../../shared/bridge-channels.js';
-import type { WorkbenchContext } from '../services/workbench-context.js';
-import type { DebugTap } from '@dimina-kit/electron-deck/main';
+export * from '@dimina-kit/electron-runtime/main/bridge-router';
+import { type RuntimeContext, type RuntimeEvents } from '@dimina-kit/electron-runtime/main/runtime-context';
+import type { SessionRuntimeStatus, SyncStorageChange } from '@dimina-kit/electron-runtime';
+import type { MessageEnvelope } from '../../shared/bridge-channels.js';
+type DevtoolsBridgeContext = Omit<RuntimeContext, 'events'> & {
+    events?: RuntimeEvents;
+    notify?: {
+        sessionRuntimeStatus(payload: SessionRuntimeStatus): void;
+    };
+    appData?: {
+        evictBridge(appId: string, bridgeId: string): void;
+        onServiceToRender(appId: string, message: MessageEnvelope): void;
+    };
+    onServiceStorageChanged?: (appId: string, change: SyncStorageChange) => void;
+};
 /**
- * Watchdog window a spawned session gets to reach `'running'` (root page
- * `domReady`) before `handleSpawn`'s launch timer reports `'launch-failed'`
- * with `code: 'timeout'`. Exported so tests can assert against the real
- * constant instead of a magic number.
+ * DevTools compatibility assembly. New contexts already own RuntimeEvents;
+ * narrow historical test/downstream contexts are upgraded here so the runtime
+ * package itself stays unaware of panels and renderer notifications.
  */
-export declare const LAUNCH_TIMEOUT_MS = 20000;
-/** Default timeout for a simulator-forwarded API call. */
-/**
- * Accessor over the bridge-router's private `RouterState`, stashed on
- * `ctx.bridge` so other main-process services (simulator-storage, automation,
- * appdata) can resolve live WebContents handles without owning router state.
- * All getters resolve fresh each call (the pre-warm pool can swap windows on
- * respawn, so cached handles go stale).
- */
-/**
- * Render-side activity worth re-reading panel data on: a page's DOM mounted
- * (`domReady`), the visible page changed (`activePage`), or the active page's
- * DOM mutated in place (`domMutated`, from the render-guest MutationObserver).
- * Panels that pull from the active render guest (WXML/element-inspect) subscribe
- * via `BridgeRouterHandle.onRenderEvent` so they can refresh without polling.
- */
-export interface RenderEvent {
-    kind: 'domReady' | 'activePage' | 'domMutated';
-    appId: string;
-    bridgeId: string;
-    /** activePage only: the now-visible page's route (bare pagePath), if known.
-     * Lets the current-page panel push the route without a separate lookup. */
-    pagePath?: string;
-}
-/**
- * Fires once per app session, the moment its hidden SERVICE HOST window's
- * `service.html` document has `did-finish-load`'d — i.e. `serviceWcId` is
- * GUARANTEED resolvable via `webContents.fromId(serviceWcId)` right now. This
- * is document readiness, NOT mini-app runtime readiness: `injectLogicBundle`
- * and the service's own `serviceResourceLoaded` handshake both happen AFTER
- * this fires (see `bootServiceHost`) — a consumer that needs "the mini-app
- * has actually booted" must not treat this as that signal.
- *
- * Exists so a consumer that needs to act on the service host wc THE MOMENT it
- * becomes resolvable (e.g. attaching the right-panel DevTools front-end) has
- * a real event to react to instead of polling `getServiceWc(appId)` on a
- * fixed retry budget and silently giving up if that budget is exhausted
- * before the wc resolves under load — the bug this event was added to fix
- * (see `native-simulator-devtools-host.ts`'s `onServiceHostReady` subscriber).
- *
- * `appId`-keyed resolution (`getServiceWc(appId)`) is NOT equivalent to this
- * event during same-app respawn overlap — `getServiceWc` returns the MOST
- * RECENT live session for that appId, which may not be the specific session
- * that just fired this event. Consumers that must target the EXACT session
- * should resolve `serviceWcId` directly rather than re-resolving by `appId`.
- */
-export interface ServiceHostReadyEvent {
-    appId: string;
-    appSessionId: string;
-    serviceWcId: number;
-}
-/**
- * Point-in-time counts of every resource class RouterState owns. Leak coverage
- * (unit + e2e) asserts EXACT equality of this ledger around a churn cycle —
- * coarse memory sampling cannot see a leaked listener or a stale map entry, so
- * the owner of the bookkeeping reports precise counts instead.
- */
-export interface BridgeResourceCensus {
-    appSessions: number;
-    pageSessions: number;
-    serviceWcBindings: number;
-    /** Distinct live simulator webContents currently hosting ≥1 session. */
-    simulatorWcs: number;
-    /** Total session memberships across all simulator wcs. */
-    simulatorWcBindings: number;
-    renderWcBindings: number;
-    pendingApiCalls: number;
-    /**
-     * `listenerCount('destroyed')` per unique live simulator wc (keyed by wc id).
-     * One teardown hook per live session — a count above the hosted-session count
-     * is the one-dead-listener-per-soft-reload leak class.
-     */
-    simulatorDestroyedListeners: Record<number, number>;
-}
-export interface BridgeRouterHandle {
-    /** Whether native-host mode is on (main is the source of truth). */
-    isNativeHost(): boolean;
-    /** The render-host `<webview>` WebContents for a page bridgeId, or null. */
-    resolveRenderWc(bridgeId: string): WebContents | null;
-    /** The hidden service-host window WebContents for the active (or named) app. */
-    getServiceWc(appId?: string): WebContents | null;
-    /** The service-host window WebContents for the app that owns a page bridgeId,
-     * or null. Lets render-side consumers (console forwarder) target the matching
-     * app's service host even with multiple sessions open. */
-    getServiceWcForBridge(bridgeId: string): WebContents | null;
-    /** The visible page's render WebContents for the active (or named) app. */
-    getActiveRenderWc(appId?: string): WebContents | null;
-    /** The visible top-of-stack page bridgeId for the active (or named) app. */
-    getActiveBridgeId(appId?: string): string | null;
-    /** The full ordered page stack (bottom→top) reported by DeviceShell, or null
-     * before the first PAGE_STACK signal. Optional: only the native-host bridge
-     * provides it (the default path derives the stack from the simulator URL). */
-    getPageStack?(appId?: string): PageStackEntry[] | null;
-    /** The current (or named) app session's resource-server baseUrl (serves
-     * that session's framework js/css), or null when no matching session
-     * exists. Per-session, never a global singleton — see AppSession.resourceBaseUrl. */
-    getResourceBaseUrl?(appId?: string): string | null;
-    /** Subscribe to render-side activity (domReady / active-page change). */
-    onRenderEvent(listener: (event: RenderEvent) => void): () => void;
-    /** Subscribe to a service host's `did-finish-load` readiness (see
-     * `ServiceHostReadyEvent`'s doc comment). A subscriber registering after
-     * the still-live session's event already fired gets a missed-signal
-     * catch-up — it never needs to poll. */
-    onServiceHostReady(listener: (event: ServiceHostReadyEvent) => void): () => void;
-    /** The currently-selected device (renderer toolbar), or null pre-selection. */
-    getDevice(): NativeDeviceInfo | null;
-    /** Cache the selected device + push DEVICE_CHANGE to the live simulator WC(s). */
-    setDevice(device: NativeDeviceInfo): void;
-    /**
-     * Deterministically tear down every app session bound to the given simulator
-     * WebContentsView id (project close / DeviceShell respawn). The session
-     * mappings are cleared, the render-host guest webContents are closed, and the
-     * service-host window is closed/released — synchronously, instead of waiting
-     * on the WCV's async `'destroyed'` cascade — so the next project never
-     * re-resolves or screenshots the outgoing project's render guest. Idempotent
-     * with the `simulatorWc.once('destroyed')` hook (`disposeAppSession`
-     * early-returns once a session is gone). Optional so partial test mocks of the
-     * handle need not stub it.
-     *
-     * The synchronous prefix of the underlying disposeAppSession clears every map
-     * + closes the render guests + the service window before it awaits, so the
-     * bridge is clean the moment this is called. The returned promise resolves
-     * after the async tail (pool.release / resourceServer.close) so the lifecycle
-     * owner can sequence a reopen after full teardown. NOTE: disposeAppSession
-     * catches and logs pool/resource-release failures internally, so the promise
-     * resolves rather than rejecting on those — it is a completion signal, not an
-     * error channel.
-     */
-    disposeSessionsForSimulator?(simulatorWcId: number): Promise<void>;
-    /**
-     * The router's resource ledger (see BridgeResourceCensus). Optional so the
-     * many partial BridgeRouterHandle test mocks don't each have to stub it.
-     */
-    census?(): BridgeResourceCensus;
-    /**
-     * The flag-gated debugTap (see foundation.md) over the bridge message stream. Exposed so a
-     * hidden devtools panel / automation can read `.entries()` when
-     * `DIMINA_DEBUG_TAP=1`; a no-op snapshot otherwise. Optional so the many
-     * partial `BridgeRouterHandle` test mocks don't each have to stub it.
-     */
-    debugTap?: DebugTap;
-}
-export declare function installBridgeRouter(ctx: WorkbenchContext): void;
+export declare function installBridgeRouter(ctx: DevtoolsBridgeContext): void;
 //# sourceMappingURL=bridge-router.d.ts.map